swarmdo 1.4.8 → 1.5.0

package/v3/@swarmdo/testing/dist/regression/regression-runner.d.ts

@@ -1,124 +0,0 @@
-/**
- * Regression Test Runner
- *
- * Orchestrates all regression tests and generates comprehensive reports.
- *
- * @module v3/testing/regression/regression-runner
- */
-import { type BaselineComparison } from './performance-baseline.js';
-import { type SecurityReport } from './security-regression.js';
-import { type ContractValidation } from './api-contract.js';
-import { type IntegrationResult } from './integration-regression.js';
-/**
- * Regression test configuration
- */
-export interface RegressionConfig {
-    /** Enable performance regression tests */
-    performanceTests: boolean;
-    /** Enable security regression tests */
-    securityTests: boolean;
-    /** Enable API contract tests */
-    contractTests: boolean;
-    /** Enable integration tests */
-    integrationTests: boolean;
-    /** Performance threshold (percentage allowed degradation) */
-    performanceThreshold: number;
-    /** Path to baseline data */
-    baselinePath: string;
-    /** Output path for reports */
-    reportPath: string;
-    /** Fail on any regression */
-    failOnRegression: boolean;
-    /** Verbose output */
-    verbose: boolean;
-}
-/**
- * Individual test result
- */
-export interface RegressionResult {
-    category: 'performance' | 'security' | 'contract' | 'integration';
-    name: string;
-    passed: boolean;
-    message: string;
-    details?: Record<string, unknown>;
-    duration: number;
-}
-/**
- * Complete regression report
- */
-export interface RegressionReport {
-    timestamp: Date;
-    duration: number;
-    passed: boolean;
-    totalTests: number;
-    passedTests: number;
-    failedTests: number;
-    skippedTests: number;
-    performance: {
-        tested: boolean;
-        results: BaselineComparison[];
-        regressions: string[];
-    };
-    security: {
-        tested: boolean;
-        report: SecurityReport | null;
-        newVulnerabilities: string[];
-    };
-    contract: {
-        tested: boolean;
-        results: ContractValidation[];
-        breakingChanges: string[];
-    };
-    integration: {
-        tested: boolean;
-        results: IntegrationResult[];
-        failures: string[];
-    };
-    summary: string;
-}
-/**
- * Regression Test Runner
- *
- * Coordinates all regression testing activities.
- */
-export declare class RegressionTestRunner {
-    private readonly config;
-    private readonly performanceBaseline;
-    private readonly securityChecker;
-    private readonly contractValidator;
-    private readonly integrationSuite;
-    constructor(config?: Partial<RegressionConfig>);
-    /**
-     * Run all configured regression tests
-     */
-    runAll(): Promise<RegressionReport>;
-    /**
-     * Run only performance regression tests
-     */
-    runPerformance(): Promise<BaselineComparison[]>;
-    /**
-     * Run only security regression tests
-     */
-    runSecurity(): Promise<SecurityReport>;
-    /**
-     * Run only API contract tests
-     */
-    runContracts(): Promise<ContractValidation[]>;
-    /**
-     * Run only integration tests
-     */
-    runIntegration(): Promise<IntegrationResult[]>;
-    /**
-     * Update baselines with current values
-     */
-    updateBaselines(): Promise<void>;
-    /**
-     * Generate human-readable summary
-     */
-    private generateSummary;
-    /**
-     * Log message if verbose mode is enabled
-     */
-    private log;
-}
-//# sourceMappingURL=regression-runner.d.ts.map

package/v3/@swarmdo/testing/dist/regression/regression-runner.js

@@ -1,227 +0,0 @@
-/**
- * Regression Test Runner
- *
- * Orchestrates all regression tests and generates comprehensive reports.
- *
- * @module v3/testing/regression/regression-runner
- */
-import { PerformanceBaseline } from './performance-baseline.js';
-import { SecurityRegressionChecker } from './security-regression.js';
-import { APIContractValidator } from './api-contract.js';
-import { IntegrationRegressionSuite } from './integration-regression.js';
-/**
- * Default configuration
- */
-const DEFAULT_CONFIG = {
-    performanceTests: true,
-    securityTests: true,
-    contractTests: true,
-    integrationTests: true,
-    performanceThreshold: 10, // 10% degradation allowed
-    baselinePath: './.regression-baselines',
-    reportPath: './.regression-reports',
-    failOnRegression: true,
-    verbose: false,
-};
-/**
- * Regression Test Runner
- *
- * Coordinates all regression testing activities.
- */
-export class RegressionTestRunner {
-    config;
-    performanceBaseline;
-    securityChecker;
-    contractValidator;
-    integrationSuite;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.performanceBaseline = new PerformanceBaseline(this.config);
-        this.securityChecker = new SecurityRegressionChecker();
-        this.contractValidator = new APIContractValidator();
-        this.integrationSuite = new IntegrationRegressionSuite();
-    }
-    /**
-     * Run all configured regression tests
-     */
-    async runAll() {
-        const startTime = Date.now();
-        const results = [];
-        const report = {
-            timestamp: new Date(),
-            duration: 0,
-            passed: true,
-            totalTests: 0,
-            passedTests: 0,
-            failedTests: 0,
-            skippedTests: 0,
-            performance: { tested: false, results: [], regressions: [] },
-            security: { tested: false, report: null, newVulnerabilities: [] },
-            contract: { tested: false, results: [], breakingChanges: [] },
-            integration: { tested: false, results: [], failures: [] },
-            summary: '',
-        };
-        // Run performance tests
-        if (this.config.performanceTests) {
-            this.log('Running performance regression tests...');
-            report.performance.tested = true;
-            report.performance.results = await this.performanceBaseline.compare();
-            report.performance.regressions = report.performance.results
-                .filter((r) => r.regression && r.degradation > this.config.performanceThreshold)
-                .map((r) => `${r.metric}: ${r.degradation.toFixed(1)}% degradation`);
-            if (report.performance.regressions.length > 0) {
-                report.passed = false;
-            }
-        }
-        // Run security tests
-        if (this.config.securityTests) {
-            this.log('Running security regression tests...');
-            report.security.tested = true;
-            report.security.report = await this.securityChecker.check();
-            report.security.newVulnerabilities = report.security.report?.newIssues || [];
-            if (report.security.newVulnerabilities.length > 0) {
-                report.passed = false;
-            }
-        }
-        // Run contract tests
-        if (this.config.contractTests) {
-            this.log('Running API contract tests...');
-            report.contract.tested = true;
-            report.contract.results = await this.contractValidator.validateAll();
-            report.contract.breakingChanges = report.contract.results
-                .filter((r) => !r.valid && r.breaking)
-                .map((r) => `${r.endpoint}: ${r.message}`);
-            if (report.contract.breakingChanges.length > 0) {
-                report.passed = false;
-            }
-        }
-        // Run integration tests
-        if (this.config.integrationTests) {
-            this.log('Running integration regression tests...');
-            report.integration.tested = true;
-            report.integration.results = await this.integrationSuite.runAll();
-            report.integration.failures = report.integration.results
-                .filter((r) => !r.passed)
-                .map((r) => `${r.name}: ${r.error}`);
-            if (report.integration.failures.length > 0) {
-                report.passed = false;
-            }
-        }
-        // Calculate summary
-        report.duration = Date.now() - startTime;
-        report.totalTests =
-            report.performance.results.length +
-                (report.security.report?.checks.length || 0) +
-                report.contract.results.length +
-                report.integration.results.length;
-        report.passedTests = report.totalTests - (report.performance.regressions.length +
-            report.security.newVulnerabilities.length +
-            report.contract.breakingChanges.length +
-            report.integration.failures.length);
-        report.failedTests = report.totalTests - report.passedTests;
-        report.summary = this.generateSummary(report);
-        return report;
-    }
-    /**
-     * Run only performance regression tests
-     */
-    async runPerformance() {
-        return this.performanceBaseline.compare();
-    }
-    /**
-     * Run only security regression tests
-     */
-    async runSecurity() {
-        return this.securityChecker.check();
-    }
-    /**
-     * Run only API contract tests
-     */
-    async runContracts() {
-        return this.contractValidator.validateAll();
-    }
-    /**
-     * Run only integration tests
-     */
-    async runIntegration() {
-        return this.integrationSuite.runAll();
-    }
-    /**
-     * Update baselines with current values
-     */
-    async updateBaselines() {
-        await this.performanceBaseline.captureBaseline();
-        await this.contractValidator.captureContracts();
-        this.log('Baselines updated successfully');
-    }
-    /**
-     * Generate human-readable summary
-     */
-    generateSummary(report) {
-        const lines = [
-            '═══════════════════════════════════════════════════════════════',
-            '                    REGRESSION TEST REPORT                      ',
-            '═══════════════════════════════════════════════════════════════',
-            '',
-            `Status: ${report.passed ? '✅ PASSED' : '❌ FAILED'}`,
-            `Duration: ${report.duration}ms`,
-            `Tests: ${report.passedTests}/${report.totalTests} passed`,
-            '',
-        ];
-        if (report.performance.tested) {
-            lines.push('📊 Performance:');
-            if (report.performance.regressions.length === 0) {
-                lines.push('   ✅ No performance regressions detected');
-            }
-            else {
-                lines.push(`   ❌ ${report.performance.regressions.length} regressions:`);
-                report.performance.regressions.forEach((r) => lines.push(`      - ${r}`));
-            }
-            lines.push('');
-        }
-        if (report.security.tested) {
-            lines.push('🔒 Security:');
-            if (report.security.newVulnerabilities.length === 0) {
-                lines.push('   ✅ No new security vulnerabilities');
-            }
-            else {
-                lines.push(`   ❌ ${report.security.newVulnerabilities.length} new vulnerabilities:`);
-                report.security.newVulnerabilities.forEach((v) => lines.push(`      - ${v}`));
-            }
-            lines.push('');
-        }
-        if (report.contract.tested) {
-            lines.push('📋 API Contracts:');
-            if (report.contract.breakingChanges.length === 0) {
-                lines.push('   ✅ No breaking changes detected');
-            }
-            else {
-                lines.push(`   ❌ ${report.contract.breakingChanges.length} breaking changes:`);
-                report.contract.breakingChanges.forEach((c) => lines.push(`      - ${c}`));
-            }
-            lines.push('');
-        }
-        if (report.integration.tested) {
-            lines.push('🔗 Integration:');
-            if (report.integration.failures.length === 0) {
-                lines.push('   ✅ All integration tests passed');
-            }
-            else {
-                lines.push(`   ❌ ${report.integration.failures.length} failures:`);
-                report.integration.failures.forEach((f) => lines.push(`      - ${f}`));
-            }
-            lines.push('');
-        }
-        lines.push('═══════════════════════════════════════════════════════════════');
-        return lines.join('\n');
-    }
-    /**
-     * Log message if verbose mode is enabled
-     */
-    log(message) {
-        if (this.config.verbose) {
-            console.log(`[Regression] ${message}`);
-        }
-    }
-}
-//# sourceMappingURL=regression-runner.js.map

package/v3/@swarmdo/testing/dist/regression/security-regression.d.ts

@@ -1,73 +0,0 @@
-/**
- * Security Regression Checker
- *
- * Detects new security vulnerabilities and regressions.
- *
- * @module v3/testing/regression/security-regression
- */
-/**
- * Security check definition
- */
-export interface SecurityCheck {
-    id: string;
-    name: string;
-    description: string;
-    severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
-    passed: boolean;
-    message: string;
-    location?: string;
-    line?: number;
-}
-/**
- * Security vulnerability
- */
-export interface SecurityVulnerability {
-    id: string;
-    type: string;
-    severity: 'critical' | 'high' | 'medium' | 'low';
-    file: string;
-    line: number;
-    description: string;
-    recommendation: string;
-    cwe?: string;
-}
-/**
- * Security report
- */
-export interface SecurityReport {
-    timestamp: Date;
-    duration: number;
-    passed: boolean;
-    checks: SecurityCheck[];
-    vulnerabilities: SecurityVulnerability[];
-    newIssues: string[];
-    resolvedIssues: string[];
-    summary: {
-        critical: number;
-        high: number;
-        medium: number;
-        low: number;
-    };
-}
-/**
- * Security Regression Checker
- *
- * Scans codebase for security vulnerabilities.
- */
-export declare class SecurityRegressionChecker {
-    private readonly basePath;
-    constructor(basePath?: string);
-    /**
-     * Run full security check
-     */
-    check(): Promise<SecurityReport>;
-    /**
-     * Find all scannable files
-     */
-    private findFiles;
-    /**
-     * Scan a single file for vulnerabilities
-     */
-    private scanFile;
-}
-//# sourceMappingURL=security-regression.d.ts.map

package/v3/@swarmdo/testing/dist/regression/security-regression.js

@@ -1,258 +0,0 @@
-/**
- * Security Regression Checker
- *
- * Detects new security vulnerabilities and regressions.
- *
- * @module v3/testing/regression/security-regression
- */
-import { readFile, readdir } from 'fs/promises';
-import { join, extname } from 'path';
-/**
- * Security patterns to check
- */
-const SECURITY_PATTERNS = [
-    {
-        id: 'sql-injection',
-        name: 'SQL Injection',
-        pattern: /\$\{[^}]*\}.*(?:SELECT|INSERT|UPDATE|DELETE|FROM|WHERE)/gi,
-        altPattern: /['"`]\s*\+\s*\w+.*(?:SELECT|INSERT|UPDATE|DELETE|FROM|WHERE)/gi,
-        severity: 'critical',
-        cwe: 'CWE-89',
-        description: 'Potential SQL injection vulnerability',
-        recommendation: 'Use parameterized queries instead of string concatenation',
-    },
-    {
-        id: 'command-injection',
-        name: 'Command Injection',
-        pattern: /exec\s*\(\s*['"`].*\$\{|exec\s*\(\s*\w+\s*\+/gi,
-        altPattern: /child_process.*exec.*\+|spawn.*shell:\s*true/gi,
-        severity: 'critical',
-        cwe: 'CWE-78',
-        description: 'Potential command injection vulnerability',
-        recommendation: 'Avoid shell execution with user input; use parameterized commands',
-    },
-    {
-        id: 'path-traversal',
-        name: 'Path Traversal',
-        pattern: /\.\.\//g,
-        altPattern: /path\.join.*req\.|path\.resolve.*req\./gi,
-        severity: 'high',
-        cwe: 'CWE-22',
-        description: 'Potential path traversal vulnerability',
-        recommendation: 'Validate and sanitize file paths; use path.normalize()',
-    },
-    {
-        id: 'weak-random',
-        name: 'Weak Random',
-        pattern: /Math\.random\(\)/g,
-        severity: 'medium',
-        cwe: 'CWE-330',
-        description: 'Use of weak random number generator',
-        recommendation: 'Use crypto.randomBytes() or crypto.randomUUID() for security-sensitive operations',
-    },
-    {
-        id: 'hardcoded-secret',
-        name: 'Hardcoded Secret',
-        pattern: /(?:password|secret|api_key|apikey|token)\s*[=:]\s*['"][^'"]{8,}/gi,
-        severity: 'high',
-        cwe: 'CWE-798',
-        description: 'Potential hardcoded secret or credential',
-        recommendation: 'Use environment variables or secure vault for secrets',
-    },
-    {
-        id: 'cors-wildcard',
-        name: 'CORS Wildcard',
-        pattern: /origin:\s*['"]?\*/gi,
-        altPattern: /Access-Control-Allow-Origin.*\*/gi,
-        severity: 'medium',
-        cwe: 'CWE-942',
-        description: 'Permissive CORS configuration',
-        recommendation: 'Specify explicit allowed origins instead of wildcard',
-    },
-    {
-        id: 'eval-usage',
-        name: 'Eval Usage',
-        pattern: /\beval\s*\(/gi,
-        altPattern: /new\s+Function\s*\(/gi,
-        severity: 'high',
-        cwe: 'CWE-95',
-        description: 'Use of eval() or dynamic code execution',
-        recommendation: 'Avoid eval(); use safer alternatives like JSON.parse()',
-    },
-    {
-        id: 'unsafe-regex',
-        name: 'Unsafe Regex',
-        pattern: /new\s+RegExp\s*\(\s*\w+\s*\)/gi,
-        severity: 'medium',
-        cwe: 'CWE-1333',
-        description: 'Potentially unsafe dynamic regex construction',
-        recommendation: 'Validate and escape regex input; consider using regex-safe libraries',
-    },
-    {
-        id: 'missing-csrf',
-        name: 'Missing CSRF Protection',
-        pattern: /router\.(?:post|put|patch|delete)\s*\([^)]*\)/gi,
-        severity: 'medium',
-        cwe: 'CWE-352',
-        description: 'Endpoint may lack CSRF protection',
-        recommendation: 'Implement CSRF tokens for state-changing operations',
-    },
-    {
-        id: 'insecure-http',
-        name: 'Insecure HTTP',
-        pattern: /http:\/\/(?!localhost|127\.0\.0\.1)/gi,
-        severity: 'low',
-        cwe: 'CWE-319',
-        description: 'Use of insecure HTTP protocol',
-        recommendation: 'Use HTTPS for all external communications',
-    },
-];
-/**
- * File extensions to scan
- */
-const SCANNABLE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-/**
- * Directories to exclude
- */
-const EXCLUDED_DIRS = ['node_modules', 'dist', 'build', '.git', 'coverage', '__tests__'];
-/**
- * Security Regression Checker
- *
- * Scans codebase for security vulnerabilities.
- */
-export class SecurityRegressionChecker {
-    basePath;
-    constructor(basePath = process.cwd()) {
-        this.basePath = basePath;
-    }
-    /**
-     * Run full security check
-     */
-    async check() {
-        const startTime = Date.now();
-        const vulnerabilities = [];
-        const checks = [];
-        // Scan all TypeScript/JavaScript files
-        const files = await this.findFiles(join(this.basePath, 'v3'));
-        for (const file of files) {
-            const fileVulns = await this.scanFile(file);
-            vulnerabilities.push(...fileVulns);
-        }
-        // Create checks from patterns
-        for (const pattern of SECURITY_PATTERNS) {
-            const patternVulns = vulnerabilities.filter((v) => v.type === pattern.id);
-            checks.push({
-                id: pattern.id,
-                name: pattern.name,
-                description: pattern.description,
-                severity: pattern.severity,
-                passed: patternVulns.length === 0,
-                message: patternVulns.length === 0
-                    ? `No ${pattern.name} vulnerabilities found`
-                    : `Found ${patternVulns.length} potential ${pattern.name} issues`,
-            });
-        }
-        // Calculate summary
-        const summary = {
-            critical: vulnerabilities.filter((v) => v.severity === 'critical').length,
-            high: vulnerabilities.filter((v) => v.severity === 'high').length,
-            medium: vulnerabilities.filter((v) => v.severity === 'medium').length,
-            low: vulnerabilities.filter((v) => v.severity === 'low').length,
-        };
-        const report = {
-            timestamp: new Date(),
-            duration: Date.now() - startTime,
-            passed: summary.critical === 0 && summary.high === 0,
-            checks,
-            vulnerabilities,
-            newIssues: vulnerabilities.map((v) => `${v.severity.toUpperCase()}: ${v.type} in ${v.file}:${v.line}`),
-            resolvedIssues: [],
-            summary,
-        };
-        return report;
-    }
-    /**
-     * Find all scannable files
-     */
-    async findFiles(dir) {
-        const files = [];
-        try {
-            const entries = await readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    if (!EXCLUDED_DIRS.includes(entry.name)) {
-                        const subFiles = await this.findFiles(fullPath);
-                        files.push(...subFiles);
-                    }
-                }
-                else if (entry.isFile()) {
-                    if (SCANNABLE_EXTENSIONS.includes(extname(entry.name))) {
-                        files.push(fullPath);
-                    }
-                }
-            }
-        }
-        catch {
-            // Directory doesn't exist or not accessible
-        }
-        return files;
-    }
-    /**
-     * Scan a single file for vulnerabilities
-     */
-    async scanFile(filePath) {
-        const vulnerabilities = [];
-        try {
-            const content = await readFile(filePath, 'utf-8');
-            const lines = content.split('\n');
-            for (const pattern of SECURITY_PATTERNS) {
-                // Skip weak-random checks in test files
-                if (pattern.id === 'weak-random' && filePath.includes('test')) {
-                    continue;
-                }
-                for (let i = 0; i < lines.length; i++) {
-                    const line = lines[i];
-                    // Check main pattern
-                    if (pattern.pattern.test(line)) {
-                        // Reset lastIndex for global patterns
-                        pattern.pattern.lastIndex = 0;
-                        vulnerabilities.push({
-                            id: `${pattern.id}-${filePath}-${i + 1}`,
-                            type: pattern.id,
-                            severity: pattern.severity,
-                            file: filePath.replace(this.basePath + '/', ''),
-                            line: i + 1,
-                            description: pattern.description,
-                            recommendation: pattern.recommendation,
-                            cwe: pattern.cwe,
-                        });
-                    }
-                    // Check alternate pattern if exists
-                    if (pattern.altPattern && pattern.altPattern.test(line)) {
-                        pattern.altPattern.lastIndex = 0;
-                        // Avoid duplicates
-                        const existingVuln = vulnerabilities.find((v) => v.type === pattern.id && v.line === i + 1 && v.file === filePath.replace(this.basePath + '/', ''));
-                        if (!existingVuln) {
-                            vulnerabilities.push({
-                                id: `${pattern.id}-${filePath}-${i + 1}`,
-                                type: pattern.id,
-                                severity: pattern.severity,
-                                file: filePath.replace(this.basePath + '/', ''),
-                                line: i + 1,
-                                description: pattern.description,
-                                recommendation: pattern.recommendation,
-                                cwe: pattern.cwe,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        catch {
-            // File not readable
-        }
-        return vulnerabilities;
-    }
-}
-//# sourceMappingURL=security-regression.js.map