qa360 2.1.2 → 2.1.4

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

@@ -0,0 +1,474 @@
+/**
+ * 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

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