qa360 2.1.2 → 2.1.4

package/dist/core/generation/test-optimizer.d.ts

@@ -1,117 +0,0 @@
-/**
- * QA360 Test Optimizer
- *
- * Optimizes generated tests for better quality and maintainability.
- * Removes redundancy, improves assertions, and enhances performance.
- */
-import type { GeneratedTest } from './types.js';
-/**
- * Optimization options
- */
-export interface OptimizationOptions {
-    /**
-     * Remove duplicate tests
-     */
-    removeDuplicates?: boolean;
-    /**
-     * Merge similar tests
-     */
-    mergeSimilarTests?: boolean;
-    /**
-     * Improve assertions
-     */
-    improveAssertions?: boolean;
-    /**
-     * Add performance optimizations
-     */
-    addPerformanceOptimizations?: boolean;
-    /**
-     * Reduce test flakiness
-     */
-    reduceFlakiness?: boolean;
-    /**
-     * Target maximum test count
-     */
-    maxTestCount?: number;
-}
-/**
- * Optimization result
- */
-export interface OptimizationResult {
-    optimized: GeneratedTest[];
-    removed: number;
-    merged: number;
-    improvements: string[];
-}
-/**
- * Test Optimizer class
- */
-export declare class TestOptimizer {
-    private readonly options;
-    private readonly defaultOptions;
-    constructor(options?: OptimizationOptions);
-    /**
-     * Optimize generated tests
-     */
-    optimize(tests: GeneratedTest[]): OptimizationResult;
-    /**
-     * Remove duplicate tests
-     */
-    private removeDuplicateTests;
-    /**
-     * Merge similar test cases
-     */
-    private mergeSimilarTestCases;
-    /**
-     * Improve test assertions
-     */
-    private improveTestAssertions;
-    /**
-     * Add performance improvements
-     */
-    private addPerformanceImprovements;
-    /**
-     * Reduce test flakiness
-     */
-    private reduceTestFlakiness;
-    /**
-     * Prioritize tests by importance
-     */
-    private prioritizeTests;
-    /**
-     * Create test signature for deduplication
-     */
-    private createTestSignature;
-    /**
-     * Calculate similarity between two tests
-     */
-    private calculateSimilarity;
-    /**
-     * Merge multiple tests into one
-     */
-    private mergeTests;
-    /**
-     * Extract test cases from code
-     */
-    private extractTestCases;
-    /**
-     * Enhance assertions in code
-     */
-    private enhanceAssertions;
-    /**
-     * Optimize performance
-     */
-    private optimizePerformance;
-    /**
-     * Add stability improvements
-     */
-    private addStabilityImprovements;
-    /**
-     * Get optimization suggestions for a test
-     */
-    getSuggestions(test: GeneratedTest): string[];
-}
-/**
- * Create optimizer with default config
- */
-export declare function createOptimizer(options?: OptimizationOptions): TestOptimizer;

package/dist/core/generation/test-optimizer.js

@@ -1,328 +0,0 @@
-/**
- * QA360 Test Optimizer
- *
- * Optimizes generated tests for better quality and maintainability.
- * Removes redundancy, improves assertions, and enhances performance.
- */
-/**
- * Test Optimizer class
- */
-export class TestOptimizer {
-    options;
-    defaultOptions = {
-        removeDuplicates: true,
-        mergeSimilarTests: true,
-        improveAssertions: true,
-        addPerformanceOptimizations: true,
-        reduceFlakiness: true,
-        maxTestCount: 100,
-    };
-    constructor(options = {}) {
-        this.options = { ...this.defaultOptions, ...options };
-    }
-    /**
-     * Optimize generated tests
-     */
-    optimize(tests) {
-        let optimized = [...tests];
-        const improvements = [];
-        let removed = 0;
-        let merged = 0;
-        // Remove duplicates
-        if (this.options.removeDuplicates) {
-            const before = optimized.length;
-            optimized = this.removeDuplicateTests(optimized);
-            removed = before - optimized.length;
-            if (removed > 0) {
-                improvements.push(`Removed ${removed} duplicate test(s)`);
-            }
-        }
-        // Merge similar tests
-        if (this.options.mergeSimilarTests) {
-            const before = optimized.length;
-            optimized = this.mergeSimilarTestCases(optimized);
-            merged = before - optimized.length;
-            if (merged > 0) {
-                improvements.push(`Merged ${merged} similar test(s)`);
-            }
-        }
-        // Improve assertions
-        if (this.options.improveAssertions) {
-            optimized = this.improveTestAssertions(optimized);
-            improvements.push('Improved assertions quality');
-        }
-        // Add performance optimizations
-        if (this.options.addPerformanceOptimizations) {
-            optimized = this.addPerformanceImprovements(optimized);
-            improvements.push('Added performance optimizations');
-        }
-        // Reduce flakiness
-        if (this.options.reduceFlakiness) {
-            optimized = this.reduceTestFlakiness(optimized);
-            improvements.push('Reduced test flakiness');
-        }
-        // Limit test count
-        if (this.options.maxTestCount && optimized.length > this.options.maxTestCount) {
-            const before = optimized.length;
-            optimized = this.prioritizeTests(optimized).slice(0, this.options.maxTestCount);
-            improvements.push(`Prioritized and kept ${this.options.maxTestCount} most important tests (${before - this.options.maxTestCount} removed)`);
-        }
-        return {
-            optimized,
-            removed,
-            merged,
-            improvements,
-        };
-    }
-    /**
-     * Remove duplicate tests
-     */
-    removeDuplicateTests(tests) {
-        const seen = new Set();
-        const unique = [];
-        for (const test of tests) {
-            // Create a signature based on test content
-            const signature = this.createTestSignature(test);
-            if (!seen.has(signature)) {
-                seen.add(signature);
-                unique.push(test);
-            }
-        }
-        return unique;
-    }
-    /**
-     * Merge similar test cases
-     */
-    mergeSimilarTestCases(tests) {
-        const merged = [];
-        const used = new Set();
-        for (let i = 0; i < tests.length; i++) {
-            if (used.has(i))
-                continue;
-            const current = tests[i];
-            const similar = [current];
-            // Find similar tests
-            for (let j = i + 1; j < tests.length; j++) {
-                if (used.has(j))
-                    continue;
-                const similarity = this.calculateSimilarity(current, tests[j]);
-                if (similarity.score > 0.7) {
-                    similar.push(tests[j]);
-                    used.add(j);
-                }
-            }
-            // Merge similar tests or keep as-is
-            if (similar.length > 1) {
-                merged.push(this.mergeTests(similar));
-            }
-            else {
-                merged.push(current);
-            }
-            used.add(i);
-        }
-        return merged;
-    }
-    /**
-     * Improve test assertions
-     */
-    improveTestAssertions(tests) {
-        return tests.map(test => ({
-            ...test,
-            code: this.enhanceAssertions(test.code),
-        }));
-    }
-    /**
-     * Add performance improvements
-     */
-    addPerformanceImprovements(tests) {
-        return tests.map(test => ({
-            ...test,
-            code: this.optimizePerformance(test.code, test.framework),
-        }));
-    }
-    /**
-     * Reduce test flakiness
-     */
-    reduceTestFlakiness(tests) {
-        return tests.map(test => ({
-            ...test,
-            code: this.addStabilityImprovements(test.code, test.framework),
-        }));
-    }
-    /**
-     * Prioritize tests by importance
-     */
-    prioritizeTests(tests) {
-        return tests.sort((a, b) => {
-            // Prefer tests with more assertions
-            const aAssertions = a.summary.assertionCount || 0;
-            const bAssertions = b.summary.assertionCount || 0;
-            if (aAssertions !== bAssertions) {
-                return bAssertions - aAssertions;
-            }
-            // Then prefer shorter tests (faster)
-            const aLines = a.summary.lines;
-            const bLines = b.summary.lines;
-            return aLines - bLines;
-        });
-    }
-    /**
-     * Create test signature for deduplication
-     */
-    createTestSignature(test) {
-        // Normalize code for comparison
-        const normalized = test.code
-            .replace(/\s+/g, ' ')
-            .replace(/\/\/.*$/gm, '') // Remove comments
-            .toLowerCase()
-            .trim();
-        // Simple hash of content
-        let hash = 0;
-        for (let i = 0; i < normalized.length; i++) {
-            const char = normalized.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash = hash & hash; // Convert to 32-bit integer
-        }
-        return `${test.name}-${Math.abs(hash)}`;
-    }
-    /**
-     * Calculate similarity between two tests
-     */
-    calculateSimilarity(test1, test2) {
-        // Check framework match
-        if (test1.framework !== test2.framework) {
-            return { test1, test2, score: 0 };
-        }
-        // Compare structure
-        const words1 = new Set(test1.code.toLowerCase().split(/\W+/));
-        const words2 = new Set(test2.code.toLowerCase().split(/\W+/));
-        let intersection = 0;
-        for (const word of words1) {
-            if (words2.has(word) && word.length > 4) { // Only significant words
-                intersection++;
-            }
-        }
-        const union = new Set([...words1, ...words2]).size;
-        const score = union > 0 ? intersection / union : 0;
-        return { test1, test2, score };
-    }
-    /**
-     * Merge multiple tests into one
-     */
-    mergeTests(tests) {
-        const base = tests[0];
-        const mergedName = `${base.name} (merged ${tests.length})`;
-        // Combine test code (simplified)
-        let mergedCode = base.code;
-        // Extract test cases from each and combine them
-        for (const test of tests.slice(1)) {
-            const testCases = this.extractTestCases(test.code);
-            for (const testCase of testCases) {
-                mergedCode += '\n\n' + testCase;
-            }
-        }
-        return {
-            ...base,
-            name: mergedName,
-            code: mergedCode,
-            summary: {
-                lines: mergedCode.split('\n').length,
-                testCount: tests.reduce((sum, t) => sum + (t.summary.testCount || 0), 0),
-                assertionCount: tests.reduce((sum, t) => sum + (t.summary.assertionCount || 0), 0),
-            },
-        };
-    }
-    /**
-     * Extract test cases from code
-     */
-    extractTestCases(code) {
-        const cases = [];
-        // Match test() or it() blocks
-        const testRegex = /\b(test|it)\s*\(\s*['"]([^'"]+)['"][\s\S]*?\n\s*\}\s*\)/g;
-        let match;
-        while ((match = testRegex.exec(code)) !== null) {
-            cases.push(match[0]);
-        }
-        return cases;
-    }
-    /**
-     * Enhance assertions in code
-     */
-    enhanceAssertions(code) {
-        let enhanced = code;
-        // Add status code checks for API tests
-        enhanced = enhanced.replace(/const response = await fetch\([^)]+\);\s*$/gm, '$&\n    expect(response.status).toBeGreaterThanOrEqual(200);\n    expect(response.status).toBeLessThan(300);');
-        // Add non-empty assertions for array responses
-        enhanced = enhanced.replace(/const data = await response\.json\(\);\s*$/gm, '$&\n    expect(data).toBeDefined();');
-        // Add timeout for slow operations
-        enhanced = enhanced.replace(/\bwaitForURL\(/g, 'waitForURL(');
-        return enhanced;
-    }
-    /**
-     * Optimize performance
-     */
-    optimizePerformance(code, framework) {
-        let optimized = code;
-        if (framework === 'playwright') {
-            // Add reuse of browser contexts where possible
-            optimized = optimized.replace(/test\.describe\(/g, 'test.describe.serial(');
-            // Suggest parallel test execution
-            if (!optimized.includes('test.describe.configure')) {
-                optimized = 'test.describe.configure({ mode: \'parallel\' });\n\n' + optimized;
-            }
-        }
-        // Remove unnecessary waits
-        optimized = optimized.replace(/\bpage\.waitForTimeout\(\d+\)/g, '// waitForTimeout removed - use explicit waits instead');
-        return optimized;
-    }
-    /**
-     * Add stability improvements
-     */
-    addStabilityImprovements(code, framework) {
-        let stable = code;
-        if (framework === 'playwright') {
-            // Replace waitFor with waitForSelector for more reliable waits
-            stable = stable.replace(/\bwaitFor\(/g, 'waitForSelector(');
-            // Add explicit waits for navigation
-            stable = stable.replace(/(\.click\([^)]+\))(?!.*waitFor)/g, '$1\n    await page.waitForLoadState(\'networkidle\');');
-        }
-        // Add retry logic for API tests
-        if (framework === 'playwright' && (code.includes('fetch') || code.includes('axios'))) {
-            stable = stable.replace(/test\s*\(\s*['"]([^'"]+)['"]\s*,\s*async\s+/g, 'test(\'$1 (with retry)\', async ');
-        }
-        return stable;
-    }
-    /**
-     * Get optimization suggestions for a test
-     */
-    getSuggestions(test) {
-        const suggestions = [];
-        // Check for missing assertions
-        if ((test.summary.assertionCount || 0) < (test.summary.testCount || 1)) {
-            suggestions.push('Consider adding more assertions for better coverage');
-        }
-        // Check for long tests
-        if (test.summary.lines > 200) {
-            suggestions.push('Test is very long - consider splitting into smaller tests');
-        }
-        // Check for console.log
-        if (test.code.includes('console.log')) {
-            suggestions.push('Remove console.log statements - use assertions instead');
-        }
-        // Check for hardcoded values
-        if (test.code.includes('123456') || test.code.includes('test@test')) {
-            suggestions.push('Use test fixtures instead of hardcoded values');
-        }
-        // Check for missing error handling
-        if (!test.code.includes('try') && !test.code.includes('catch')) {
-            suggestions.push('Consider adding error handling for robustness');
-        }
-        return suggestions;
-    }
-}
-/**
- * Create optimizer with default config
- */
-export function createOptimizer(options) {
-    return new TestOptimizer(options);
-}

package/dist/core/generation/types.d.ts

@@ -1,214 +0,0 @@
-/**
- * Types for AI Test Generation
- */
-/**
- * Base test specification
- */
-export interface TestSpec {
-    type: 'api' | 'ui' | 'perf' | 'unit';
-    name: string;
-    description?: string;
-    tags?: string[];
-}
-/**
- * API test specification
- */
-export interface ApiTestSpec extends TestSpec {
-    type: 'api';
-    baseUrl: string;
-    endpoints: ApiEndpoint[];
-    auth?: AuthSpec;
-    headers?: Record<string, string>;
-}
-/**
- * API endpoint definition
- */
-export interface ApiEndpoint {
-    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    path: string;
-    description?: string;
-    headers?: Record<string, string>;
-    body?: unknown;
-    queryParams?: Record<string, string>;
-    expectations?: ApiExpectation[];
-}
-/**
- * API expectations
- */
-export interface ApiExpectation {
-    status?: number | number[];
-    responseTime?: string;
-    hasBody?: boolean;
-    schema?: Record<string, unknown>;
-    contains?: string[];
-}
-/**
- * UI test specification
- */
-export interface UiTestSpec extends TestSpec {
-    type: 'ui';
-    baseUrl: string;
-    pages: PageSpec[];
-    auth?: AuthSpec;
-    viewport?: {
-        width: number;
-        height: number;
-    };
-}
-/**
- * Page specification for UI tests
- */
-export interface PageSpec {
-    name: string;
-    url: string;
-    actions: PageAction[];
-    assertions?: Assertion[];
-}
-/**
- * Page action
- */
-export interface PageAction {
-    type: 'goto' | 'click' | 'fill' | 'select' | 'wait' | 'hover' | 'screenshot' | 'type' | 'check' | 'uncheck';
-    selector?: string;
-    value?: string;
-    timeout?: number;
-    options?: Record<string, unknown>;
-}
-/**
- * Assertion for UI tests
- */
-export interface Assertion {
-    type: 'url' | 'title' | 'visible' | 'text' | 'attribute' | 'count';
-    selector?: string;
-    expected: string | number | boolean;
-    operator?: 'equals' | 'contains' | 'matches' | 'greaterThan' | 'lessThan';
-}
-/**
- * Performance test specification
- */
-export interface PerfTestSpec extends TestSpec {
-    type: 'perf';
-    baseUrl: string;
-    scenarios: PerfScenario[];
-    options?: PerfOptions;
-}
-/**
- * Performance scenario
- */
-export interface PerfScenario {
-    name: string;
-    weight?: number;
-    requests: PerfRequest[];
-    thinkTime?: number;
-}
-/**
- * Performance request
- */
-export interface PerfRequest {
-    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    path: string;
-    headers?: Record<string, string>;
-    body?: unknown;
-    timeout?: number;
-}
-/**
- * Performance test options
- */
-export interface PerfOptions {
-    duration?: string;
-    rate?: number;
-    vus?: number;
-    maxVus?: number;
-    thresholds?: PerfThreshold[];
-}
-/**
- * Performance thresholds
- */
-export interface PerfThreshold {
-    metric: 'http_req_duration' | 'http_req_failed' | 'checks';
-    condition: string;
-}
-/**
- * Unit test specification
- */
-export interface UnitTestSpec extends TestSpec {
-    type: 'unit';
-    source: {
-        language: 'typescript' | 'javascript' | 'python' | 'go' | 'rust';
-        filePath: string;
-        code?: string;
-        exports?: string[];
-    };
-    framework?: 'vitest' | 'jest' | 'pytest' | 'go test';
-}
-/**
- * Authentication specification
- */
-export interface AuthSpec {
-    type: 'none' | 'bearer' | 'basic' | 'api_key' | 'oauth2' | 'jwt';
-    config?: Record<string, unknown>;
-}
-/**
- * Generation context
- */
-export interface GenerationContext {
-    projectName: string;
-    framework: 'playwright' | 'k6' | 'vitest' | 'jest';
-    language: 'typescript' | 'javascript' | 'go';
-    outputDir?: string;
-    options?: GenerationOptions;
-}
-/**
- * Generation options
- */
-export interface GenerationOptions {
-    includeComments?: boolean;
-    includeAssertions?: boolean;
-    includeRetryLogic?: boolean;
-    optimize?: boolean;
-    targetCoverage?: number;
-    maxTests?: number;
-}
-/**
- * Generated test result
- */
-export interface GeneratedTest {
-    name: string;
-    code: string;
-    language: string;
-    framework: string;
-    filePath: string;
-    summary: {
-        lines: number;
-        testCount: number;
-        assertionCount?: number;
-    };
-    metadata?: {
-        generatedAt: string;
-        model: string;
-        tokensUsed: number;
-    };
-}
-/**
- * Source for test generation
- */
-export type GenerationSource = {
-    type: 'openapi';
-    urlOrPath: string;
-} | {
-    type: 'har';
-    filePath: string;
-} | {
-    type: 'url';
-    url: string;
-} | {
-    type: 'spec';
-    spec: TestSpec;
-} | {
-    type: 'description';
-    description: string;
-} | {
-    type: 'code';
-    code: string;
-    language: string;
-};

package/dist/core/generation/types.js

@@ -1,4 +0,0 @@
-/**
- * Types for AI Test Generation
- */
-export {};