qa360 2.2.1 → 2.2.13

package/core/src/generation/test-optimizer.ts

@@ -1,474 +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 similarity score
- */
-interface SimilarityScore {
-  test1: GeneratedTest;
-  test2: GeneratedTest;
-  score: number;  // 0-1, higher is more similar
-}
-
-/**
- * Test Optimizer class
- */
-export class TestOptimizer {
-  private readonly options: Required<OptimizationOptions>;
-
-  private readonly defaultOptions: Required<OptimizationOptions> = {
-    removeDuplicates: true,
-    mergeSimilarTests: true,
-    improveAssertions: true,
-    addPerformanceOptimizations: true,
-    reduceFlakiness: true,
-    maxTestCount: 100,
-  };
-
-  constructor(options: OptimizationOptions = {}) {
-    this.options = { ...this.defaultOptions, ...options };
-  }
-
-  /**
-   * Optimize generated tests
-   */
-  optimize(tests: GeneratedTest[]): OptimizationResult {
-    let optimized = [...tests];
-    const improvements: string[] = [];
-    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
-   */
-  private removeDuplicateTests(tests: GeneratedTest[]): GeneratedTest[] {
-    const seen = new Set<string>();
-    const unique: GeneratedTest[] = [];
-
-    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
-   */
-  private mergeSimilarTestCases(tests: GeneratedTest[]): GeneratedTest[] {
-    const merged: GeneratedTest[] = [];
-    const used = new Set<number>();
-
-    for (let i = 0; i < tests.length; i++) {
-      if (used.has(i)) continue;
-
-      const current = tests[i];
-      const similar: GeneratedTest[] = [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
-   */
-  private improveTestAssertions(tests: GeneratedTest[]): GeneratedTest[] {
-    return tests.map(test => ({
-      ...test,
-      code: this.enhanceAssertions(test.code),
-    }));
-  }
-
-  /**
-   * Add performance improvements
-   */
-  private addPerformanceImprovements(tests: GeneratedTest[]): GeneratedTest[] {
-    return tests.map(test => ({
-      ...test,
-      code: this.optimizePerformance(test.code, test.framework),
-    }));
-  }
-
-  /**
-   * Reduce test flakiness
-   */
-  private reduceTestFlakiness(tests: GeneratedTest[]): GeneratedTest[] {
-    return tests.map(test => ({
-      ...test,
-      code: this.addStabilityImprovements(test.code, test.framework),
-    }));
-  }
-
-  /**
-   * Prioritize tests by importance
-   */
-  private prioritizeTests(tests: GeneratedTest[]): GeneratedTest[] {
-    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
-   */
-  private createTestSignature(test: GeneratedTest): string {
-    // 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
-   */
-  private calculateSimilarity(test1: GeneratedTest, test2: GeneratedTest): SimilarityScore {
-    // 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
-   */
-  private mergeTests(tests: GeneratedTest[]): GeneratedTest {
-    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
-   */
-  private extractTestCases(code: string): string[] {
-    const cases: string[] = [];
-
-    // 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
-   */
-  private enhanceAssertions(code: string): string {
-    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
-   */
-  private optimizePerformance(code: string, framework: string): string {
-    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
-   */
-  private addStabilityImprovements(code: string, framework: string): string {
-    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: GeneratedTest): string[] {
-    const suggestions: string[] = [];
-
-    // 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?: OptimizationOptions): TestOptimizer {
-  return new TestOptimizer(options);
-}

package/core/src/generation/types.ts

@@ -1,217 +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;  // Traffic weight for load distribution
-  requests: PerfRequest[];
-  thinkTime?: number;  // ms
-}
-
-/**
- * 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;  // e.g., "30s", "1m"
-  rate?: number;  // requests per second
-  vus?: number;  // virtual users
-  maxVus?: number;
-  thresholds?: PerfThreshold[];
-}
-
-/**
- * Performance thresholds
- */
-export interface PerfThreshold {
-  metric: 'http_req_duration' | 'http_req_failed' | 'checks';
-  condition: string;  // e.g., "p(95)<500"
-}
-
-/**
- * Unit test specification
- */
-export interface UnitTestSpec extends TestSpec {
-  type: 'unit';
-  source: {
-    language: 'typescript' | 'javascript' | 'python' | 'go' | 'rust';
-    filePath: string;
-    code?: string;
-    exports?: string[];  // Functions/classes to test
-  };
-  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 };