qa360 2.2.1 → 2.2.13

package/cli/dist/core/adapters/pytest-adapter.d.ts

@@ -0,0 +1,49 @@
+/**
+ * QA360 Pytest Adapter
+ *
+ * Ingests Pytest test results and coverage reports into QA360.
+ *
+ * @see https://docs.pytest.org/en/stable/how-to/output.html
+ *
+ * Supported result formats:
+ * - test-results.json (from --json-report)
+ * - test-results/junit.xml (from --junitxml)
+ * - coverage.xml (from pytest-cov)
+ */
+import { UnitTestConfig, UnitTestExecutionResult } from './unit-test-types.js';
+export declare class PytestAdapter {
+    private cwd;
+    constructor(cwd?: string);
+    /**
+     * Execute Pytest tests and return results
+     */
+    execute(config: UnitTestConfig): Promise<UnitTestExecutionResult>;
+    /**
+     * Parse JUnit XML format
+     */
+    private parseJUnitXml;
+    /**
+     * Extract test cases from JUnit XML (simplified parser)
+     */
+    private extractJUnitTestCases;
+    /**
+     * Parse Coverage.py XML format
+     */
+    private parseCoverageXml;
+    /**
+     * Parse Pytest results into QA360 format
+     */
+    private parseResults;
+    /**
+     * Map Pytest status to QA360 status
+     */
+    private mapPytestStatus;
+    /**
+     * Check if coverage meets thresholds
+     */
+    private checkThresholds;
+}
+/**
+ * Create a Pytest adapter instance
+ */
+export declare function createPytestAdapter(cwd?: string): PytestAdapter;

package/cli/dist/core/adapters/pytest-adapter.js

@@ -0,0 +1,324 @@
+/**
+ * QA360 Pytest Adapter
+ *
+ * Ingests Pytest test results and coverage reports into QA360.
+ *
+ * @see https://docs.pytest.org/en/stable/how-to/output.html
+ *
+ * Supported result formats:
+ * - test-results.json (from --json-report)
+ * - test-results/junit.xml (from --junitxml)
+ * - coverage.xml (from pytest-cov)
+ */
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve, isAbsolute } from 'path';
+export class PytestAdapter {
+    cwd;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+    }
+    /**
+     * Execute Pytest tests and return results
+     */
+    async execute(config) {
+        const workDir = config.cwd || this.cwd;
+        // Helper to resolve path (handle absolute paths correctly)
+        const resolvePath = (path) => {
+            if (!path)
+                return undefined;
+            return isAbsolute(path) ? path : resolve(workDir, path);
+        };
+        // Check for results file
+        const resultsPaths = [
+            resolvePath(config.results),
+            resolve(workDir, 'test-results/pytest-results.json'),
+            resolve(workDir, 'test-results/test-results.json'),
+            resolve(workDir, 'test-results/junit.xml'),
+        ].filter(Boolean);
+        const coveragePaths = [
+            resolvePath(config.coverage),
+            resolve(workDir, 'coverage.xml'),
+            resolve(workDir, 'test-results/coverage.xml'),
+        ].filter(Boolean);
+        let results = null;
+        let coverage = null;
+        // Try to read existing results
+        for (const path of resultsPaths) {
+            if (existsSync(path)) {
+                if (path.endsWith('.json')) {
+                    const content = await readFile(path, 'utf-8');
+                    results = JSON.parse(content);
+                    break;
+                }
+                else if (path.endsWith('.xml')) {
+                    results = await this.parseJUnitXml(path);
+                    break;
+                }
+            }
+        }
+        // Try to read existing coverage
+        for (const path of coveragePaths) {
+            if (existsSync(path)) {
+                coverage = await this.parseCoverageXml(path);
+                break;
+            }
+        }
+        // If no results exist and command is provided, run tests
+        if (!results && config.command) {
+            const { execSync } = await import('child_process');
+            try {
+                const timeout = config.timeout || 60000;
+                execSync(config.command, {
+                    cwd: workDir,
+                    stdio: 'pipe',
+                    timeout,
+                });
+                // Try reading results again after running tests
+                for (const path of resultsPaths) {
+                    if (existsSync(path)) {
+                        if (path.endsWith('.json')) {
+                            const content = await readFile(path, 'utf-8');
+                            results = JSON.parse(content);
+                            break;
+                        }
+                        else if (path.endsWith('.xml')) {
+                            results = await this.parseJUnitXml(path);
+                            break;
+                        }
+                    }
+                }
+                // Try reading coverage again
+                for (const path of coveragePaths) {
+                    if (existsSync(path)) {
+                        coverage = await this.parseCoverageXml(path);
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                // Test execution failed - return error result
+                return {
+                    adapter: 'pytest',
+                    total: 0,
+                    passed: 0,
+                    failed: 0,
+                    skipped: 0,
+                    pending: 0,
+                    duration: 0,
+                    tests: [],
+                    success: false,
+                };
+            }
+        }
+        return this.parseResults(results, coverage, config.thresholds);
+    }
+    /**
+     * Parse JUnit XML format
+     */
+    async parseJUnitXml(filePath) {
+        const content = await readFile(filePath, 'utf-8');
+        // Simple XML parser for JUnit format
+        const tests = {
+            nodeid: '',
+            lineno: 0,
+            outcome: 'passed',
+            duration: 0,
+        };
+        // This is a simplified parser - for production, use a proper XML library
+        const testCases = this.extractJUnitTestCases(content);
+        const summary = {
+            total: testCases.length,
+            passed: testCases.filter(t => t.outcome === 'passed').length,
+            failed: testCases.filter(t => t.outcome === 'failed').length,
+            skipped: testCases.filter(t => t.outcome === 'skipped').length,
+            duration: testCases.reduce((sum, t) => sum + t.duration, 0),
+        };
+        return {
+            summary,
+            collected: summary,
+            tests: testCases,
+        };
+    }
+    /**
+     * Extract test cases from JUnit XML (simplified parser)
+     */
+    extractJUnitTestCases(xmlContent) {
+        const tests = [];
+        // Simple regex-based extraction (for robust XML parsing, use xml2js or similar)
+        const testCaseRegex = /<testcase[^>]*name="([^"]+)"[^>]*classname="([^"]+)"[^>]*time="([^"]+)"[^>]*>([\s\S]*?)<\/testcase>/g;
+        let match;
+        while ((match = testCaseRegex.exec(xmlContent)) !== null) {
+            const [, name, classname, time, content] = match;
+            let status = 'passed';
+            let error;
+            let duration = parseFloat(time) * 1000; // Convert to ms
+            if (content.includes('<failure')) {
+                status = 'failed';
+                const messageMatch = content.match(/<failure[^>]*message="([^"]*)"/);
+                const textMatch = content.match(/<failure[^>]*>([\s\S]*?)<\/failure>/);
+                error = messageMatch?.[1] || textMatch?.[1] || 'Test failed';
+            }
+            else if (content.includes('<error')) {
+                status = 'failed';
+                const messageMatch = content.match(/<error[^>]*message="([^"]*)"/);
+                error = messageMatch?.[1] || 'Test error';
+            }
+            else if (content.includes('<skipped')) {
+                status = 'skipped';
+            }
+            tests.push({
+                nodeid: `${classname}::${name}`,
+                lineno: 0,
+                outcome: status,
+                duration,
+                call: status === 'failed' ? { outcome: status, duration, error } : undefined,
+            });
+        }
+        return tests;
+    }
+    /**
+     * Parse Coverage.py XML format
+     */
+    async parseCoverageXml(filePath) {
+        const content = await readFile(filePath, 'utf-8');
+        // Extract rates from XML
+        const lineRateMatch = content.match(/lineRate="([^"]+)"/);
+        const branchRateMatch = content.match(/branchRate="([^"]+)"/);
+        const linesCoveredMatch = content.match(/linesCovered="([^"]+)"/);
+        const linesValidMatch = content.match(/linesValid="([^"]+)"/);
+        const branchesCoveredMatch = content.match(/branchesCovered="([^"]+)"/);
+        const branchesValidMatch = content.match(/branchesValid="([^"]+)"/);
+        const statementsPct = lineRateMatch ? parseFloat(lineRateMatch[1]) * 100 : 0;
+        const branchesPct = branchRateMatch ? parseFloat(branchRateMatch[1]) * 100 : 0;
+        const linesCovered = linesCoveredMatch ? parseInt(linesCoveredMatch[1], 10) : 0;
+        const linesValid = linesValidMatch ? parseInt(linesValidMatch[1], 10) : 0;
+        const branchesCovered = branchesCoveredMatch ? parseInt(branchesCoveredMatch[1], 10) : 0;
+        const branchesValid = branchesValidMatch ? parseInt(branchesValidMatch[1], 10) : 0;
+        // Approximate functions from statements (simplified)
+        const functionsValid = Math.round(linesValid * 0.8);
+        const functionsCovered = Math.round(linesCovered * 0.8);
+        return {
+            statements: {
+                total: linesValid,
+                covered: linesCovered,
+                percentage: statementsPct,
+            },
+            branches: {
+                total: branchesValid,
+                covered: branchesCovered,
+                percentage: branchesPct,
+            },
+            functions: {
+                total: functionsValid,
+                covered: functionsCovered,
+                percentage: statementsPct, // Approximate
+            },
+            lines: {
+                total: linesValid,
+                covered: linesCovered,
+                percentage: statementsPct,
+            },
+        };
+    }
+    /**
+     * Parse Pytest results into QA360 format
+     */
+    parseResults(results, coverage, thresholds) {
+        if (!results) {
+            // No results found and no command was provided - this is a configuration error
+            return {
+                adapter: 'pytest',
+                total: 0,
+                passed: 0,
+                failed: 0,
+                skipped: 0,
+                pending: 0,
+                duration: 0,
+                tests: [],
+                success: false,
+                error: 'No test results found. Provide either a results file path or a command to run tests.',
+            };
+        }
+        const summary = results.summary || results.collected;
+        const tests = [];
+        for (const test of results.tests) {
+            const status = this.mapPytestStatus(test.outcome);
+            const error = test.call?.error ||
+                test.call?.failure?.message ||
+                test.setup?.error ||
+                test.setup?.failure?.message;
+            // Extract test name from nodeid (format: file::test or file::class::test)
+            const parts = test.nodeid.split('::');
+            const testName = test.test_metadata?.description || parts[parts.length - 1];
+            tests.push({
+                file: parts[0] || test.nodeid,
+                name: testName,
+                fullName: test.nodeid,
+                status,
+                duration: Math.round(test.duration * 1000), // Convert to ms
+                error,
+                stack: test.call?.failure?.trace || test.setup?.failure?.trace,
+            });
+        }
+        const thresholdResults = coverage && thresholds
+            ? this.checkThresholds(coverage, thresholds)
+            : undefined;
+        // Overall success: all tests passed AND thresholds met
+        const success = (summary.failed || 0) === 0 &&
+            (!thresholdResults || (thresholdResults.statements &&
+                thresholdResults.branches &&
+                thresholdResults.functions &&
+                thresholdResults.lines));
+        return {
+            adapter: 'pytest',
+            total: summary.total,
+            passed: summary.passed,
+            failed: summary.failed,
+            skipped: summary.skipped,
+            pending: 0,
+            duration: Math.round(summary.duration * 1000),
+            tests,
+            coverage: coverage || undefined,
+            thresholdResults,
+            success,
+        };
+    }
+    /**
+     * Map Pytest status to QA360 status
+     */
+    mapPytestStatus(status) {
+        switch (status) {
+            case 'passed':
+                return 'passed';
+            case 'failed':
+                return 'failed';
+            case 'skipped':
+                return 'skipped';
+            default:
+                return 'failed';
+        }
+    }
+    /**
+     * Check if coverage meets thresholds
+     */
+    checkThresholds(coverage, thresholds) {
+        const check = (value, threshold) => {
+            if (threshold === undefined)
+                return true;
+            return value >= threshold;
+        };
+        return {
+            statements: check(coverage.statements.percentage, thresholds.statements),
+            branches: check(coverage.branches.percentage, thresholds.branches),
+            functions: check(coverage.functions.percentage, thresholds.functions),
+            lines: check(coverage.lines.percentage, thresholds.lines),
+        };
+    }
+}
+/**
+ * Create a Pytest adapter instance
+ */
+export function createPytestAdapter(cwd) {
+    return new PytestAdapter(cwd);
+}

package/cli/dist/core/adapters/semgrep-sast.d.ts

@@ -0,0 +1,99 @@
+/**
+ * QA360 Semgrep SAST Adapter (Socle OOTB)
+ * Static Application Security Testing with configurable severity thresholds
+ */
+import { PackSecurity } from '../types/pack-v1.js';
+export interface SemgrepTestConfig {
+    workingDir: string;
+    security?: PackSecurity;
+    rules?: string[];
+    paths?: string[];
+    timeout?: number;
+    configFile?: string;
+}
+export interface SemgrepFinding {
+    ruleId: string;
+    severity: 'INFO' | 'WARNING' | 'ERROR';
+    message: string;
+    file: string;
+    line: number;
+    column: number;
+    code?: string;
+    fix?: string;
+}
+export interface SemgrepTestResult {
+    success: boolean;
+    findings: SemgrepFinding[];
+    summary: {
+        total: number;
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+        info: number;
+    };
+    thresholds: {
+        sast_max_high: {
+            passed: boolean;
+            actual: number;
+            budget: number;
+        };
+    };
+    error?: string;
+    rawOutput?: string;
+    junit?: string;
+}
+export declare class SemgrepSastAdapter {
+    private redactor;
+    constructor();
+    /**
+     * Execute Semgrep SAST scan
+     */
+    runSastScan(config: SemgrepTestConfig): Promise<SemgrepTestResult>;
+    /**
+     * Execute Semgrep command
+     */
+    private executeSemgrep;
+    /**
+     * Parse Semgrep JSON results
+     */
+    private parseSemgrepResults;
+    /**
+     * Map Semgrep severity to standard levels
+     */
+    private mapSeverity;
+    /**
+     * Calculate findings summary
+     */
+    private calculateSummary;
+    /**
+     * Check security thresholds
+     */
+    private checkThresholds;
+    /**
+     * Generate JUnit XML
+     */
+    private generateJUnit;
+    /**
+     * Get default summary structure
+     */
+    private getDefaultSummary;
+    /**
+     * Get default thresholds
+     */
+    private getDefaultThresholds;
+    /**
+     * Check if Semgrep is available
+     */
+    static isAvailable(): Promise<{
+        available: boolean;
+        error?: string;
+    }>;
+    /**
+     * Validate SAST configuration
+     */
+    static validateConfig(config: SemgrepTestConfig): {
+        valid: boolean;
+        errors: string[];
+    };
+}