qa360 2.2.1 → 2.2.13

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

@@ -1,255 +0,0 @@
-/**
- * Test Optimizer Unit Tests
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { TestOptimizer } from '../test-optimizer.js';
-import type { GeneratedTest } from '../types.js';
-
-describe('TestOptimizer', () => {
-  let optimizer: TestOptimizer;
-
-  beforeEach(() => {
-    optimizer = new TestOptimizer();
-  });
-
-  describe('optimize', () => {
-    it('should remove duplicate tests', () => {
-      const tests: GeneratedTest[] = [
-        {
-          name: 'Test A',
-          code: 'console.log("test");',
-          language: 'typescript',
-          framework: 'vitest',
-          filePath: '/tests/test-a.spec.ts',
-          summary: { lines: 1, testCount: 1 },
-        },
-        {
-          name: 'Test A',  // Duplicate
-          code: 'console.log("test");',
-          language: 'typescript',
-          framework: 'vitest',
-          filePath: '/tests/test-a-2.spec.ts',
-          summary: { lines: 1, testCount: 1 },
-        },
-        {
-          name: 'Test B',
-          code: 'console.log("other");',
-          language: 'typescript',
-          framework: 'vitest',
-          filePath: '/tests/test-b.spec.ts',
-          summary: { lines: 1, testCount: 1 },
-        },
-      ];
-
-      const result = optimizer.optimize(tests);
-
-      expect(result.optimized).toHaveLength(2);  // Test A and Test B
-      expect(result.removed).toBe(1);
-      expect(result.improvements).toContain('Removed 1 duplicate test(s)');
-    });
-
-    it('should improve assertions', () => {
-      const tests: GeneratedTest[] = [
-        {
-          name: 'API Test',
-          code: 'const response = await fetch("/api/users");',
-          language: 'typescript',
-          framework: 'playwright',
-          filePath: '/tests/api.test.ts',
-          summary: { lines: 1, testCount: 1 },
-        },
-      ];
-
-      const result = optimizer.optimize(tests);
-
-      // Check that assertions were added (expect contains "status" or similar)
-      expect(result.optimized[0].code).toMatch(/status|assert|expect/);
-      expect(result.improvements).toContain('Improved assertions quality');
-    });
-
-    it('should add performance optimizations', () => {
-      const tests: GeneratedTest[] = [
-        {
-          name: 'Playwright Test',
-          code: 'test("example", async ({ page }) => { await page.click("button"); });',
-          language: 'typescript',
-          framework: 'playwright',
-          filePath: '/tests/ui.test.ts',
-          summary: { lines: 1, testCount: 1 },
-        },
-      ];
-
-      const result = optimizer.optimize(tests);
-
-      expect(result.improvements).toContain('Added performance optimizations');
-    });
-
-    it('should reduce flakiness', () => {
-      const tests: GeneratedTest[] = [
-        {
-          name: 'Network Test',
-          code: 'test("fetch", async () => { await fetch("/api"); });',
-          language: 'typescript',
-          framework: 'playwright',
-          filePath: '/tests/network.test.ts',
-          summary: { lines: 1, testCount: 1 },
-        },
-      ];
-
-      const result = optimizer.optimize(tests);
-
-      expect(result.improvements).toContain('Reduced test flakiness');
-    });
-
-    it('should limit test count when maxTestCount is set', () => {
-      const tests: GeneratedTest[] = Array.from({ length: 150 }, (_, i) => ({
-        name: `Test ${i}`,
-        code: `test('test ${i}', () => {});`,
-        language: 'typescript',
-        framework: 'vitest',
-        filePath: `/tests/test-${i}.spec.ts`,
-        summary: { lines: 1, testCount: 1, assertionCount: 1 },
-      }));
-
-      const optimizer = new TestOptimizer({ maxTestCount: 100 });
-      const result = optimizer.optimize(tests);
-
-      expect(result.optimized).toHaveLength(100);
-      // Check that any improvement mentions the number 100 or prioritization
-      expect(result.improvements.some(i => i.includes('100') || i.includes('Prioritized'))).toBe(true);
-    });
-  });
-
-  describe('getSuggestions', () => {
-    it('should suggest adding assertions for tests with low assertion count', () => {
-      const test: GeneratedTest = {
-        name: 'Test',
-        code: 'test("example", () => {});',
-        language: 'typescript',
-        framework: 'vitest',
-        filePath: '/tests/test.spec.ts',
-        summary: { lines: 1, testCount: 1, assertionCount: 0 },
-      };
-
-      const suggestions = optimizer.getSuggestions(test);
-
-      expect(suggestions).toContain('Consider adding more assertions for better coverage');
-    });
-
-    it('should suggest splitting long tests', () => {
-      const longCode = 'test("long", () => {\n' + '  expect(1).toBe(1);\n'.repeat(100) + '\n});';
-      const test: GeneratedTest = {
-        name: 'Long Test',
-        code: longCode,
-        language: 'typescript',
-        framework: 'vitest',
-        filePath: '/tests/long.spec.ts',
-        summary: { lines: 250, testCount: 1 },
-      };
-
-      const suggestions = optimizer.getSuggestions(test);
-
-      expect(suggestions).toContain('Test is very long - consider splitting into smaller tests');
-    });
-
-    it('should suggest removing console.log', () => {
-      const test: GeneratedTest = {
-        name: 'Test',
-        code: 'console.log("debug");\ntest("example", () => {});',
-        language: 'typescript',
-        framework: 'vitest',
-        filePath: '/tests/test.spec.ts',
-        summary: { lines: 2, testCount: 1 },
-      };
-
-      const suggestions = optimizer.getSuggestions(test);
-
-      expect(suggestions).toContain('Remove console.log statements - use assertions instead');
-    });
-
-    it('should suggest using fixtures for hardcoded values', () => {
-      const test: GeneratedTest = {
-        name: 'Test',
-        code: 'test("example", () => { expect(login("test@test", "123456")).toBe(true); });',
-        language: 'typescript',
-        framework: 'vitest',
-        filePath: '/tests/test.spec.ts',
-        summary: { lines: 1, testCount: 1 },
-      };
-
-      const suggestions = optimizer.getSuggestions(test);
-
-      expect(suggestions).toContain('Use test fixtures instead of hardcoded values');
-    });
-
-    it('should suggest adding error handling', () => {
-      const test: GeneratedTest = {
-        name: 'Test',
-        code: 'test("example", () => { asyncOperation(); });',
-        language: 'typescript',
-        framework: 'vitest',
-        filePath: '/tests/test.spec.ts',
-        summary: { lines: 1, testCount: 1 },
-      };
-
-      const suggestions = optimizer.getSuggestions(test);
-
-      expect(suggestions).toContain('Consider adding error handling for robustness');
-    });
-
-    it('should return empty array for good test', () => {
-      const goodTest: GeneratedTest = {
-        name: 'Good Test',
-        code: `
-          test("example", async () => {
-            const result = await service.getData();
-            expect(result).toBeDefined();
-            expect(result.id).toBe(1);
-            try {
-              await riskyOperation();
-            } catch (e) {
-              expect(e).toBeInstanceOf(Error);
-            }
-          });
-        `,
-        language: 'typescript',
-        framework: 'vitest',
-        filePath: '/tests/good.spec.ts',
-        summary: { lines: 12, testCount: 1, assertionCount: 3 },
-      };
-
-      const suggestions = optimizer.getSuggestions(goodTest);
-
-      // Should have fewer or no suggestions compared to bad tests
-      expect(suggestions.length).toBeLessThan(3);
-    });
-  });
-
-  describe('configuration', () => {
-    it('should respect removeDuplicates option', () => {
-      const optimizer = new TestOptimizer({ removeDuplicates: false });
-      const tests: GeneratedTest[] = [
-        { name: 'Test', code: 'code', language: 'ts', framework: 'vitest', filePath: '/test.ts', summary: { lines: 1, testCount: 1 } },
-        { name: 'Test', code: 'code', language: 'ts', framework: 'vitest', filePath: '/test2.ts', summary: { lines: 1, testCount: 1 } },
-      ];
-
-      const result = optimizer.optimize(tests);
-
-      expect(result.optimized).toHaveLength(2);  // Both kept
-      expect(result.removed).toBe(0);
-    });
-
-    it('should respect mergeSimilarTests option', () => {
-      const optimizer = new TestOptimizer({ mergeSimilarTests: false });
-      const tests: GeneratedTest[] = [
-        { name: 'Test A', code: 'test("a", () => {});', language: 'ts', framework: 'vitest', filePath: '/a.ts', summary: { lines: 1, testCount: 1 } },
-        { name: 'Test A2', code: 'test("a2", () => {});', language: 'ts', framework: 'vitest', filePath: '/a2.ts', summary: { lines: 1, testCount: 1 } },
-      ];
-
-      const result = optimizer.optimize(tests);
-
-      expect(result.merged).toBe(0);
-    });
-  });
-});

package/core/src/generation/code-formatter.ts

@@ -1,408 +0,0 @@
-/**
- * QA360 Code Formatter
- *
- * Formats and validates generated test code.
- * Supports TypeScript, JavaScript, Go, and Python.
- */
-
-/**
- * Formatter configuration
- */
-export interface FormatterConfig {
-  /**
-   * Indentation style
-   */
-  indentStyle?: 'spaces' | 'tabs';
-
-  /**
-   * Indentation size
-   */
-  indentSize?: number;
-
-  /**
-   * Line width
-   */
-  lineWidth?: number;
-
-  /**
-   * Semicolons (for JS/TS)
-   */
-  semicolons?: boolean;
-
-  /**
-   * Quotes style
-   */
-  quotes?: 'single' | 'double';
-
-  /**
-   * Trailing commas
-   */
-  trailingCommas?: boolean;
-
-  /**
-   * Sort imports
-   */
-  sortImports?: boolean;
-}
-
-/**
- * Formatting result
- */
-export interface FormatResult {
-  formatted: string;
-  errors: string[];
-  warnings: string[];
-}
-
-/**
- * Code Formatter class
- */
-export class CodeFormatter {
-  private readonly config: Required<FormatterConfig>;
-
-  private readonly defaultConfig: Required<FormatterConfig> = {
-    indentStyle: 'spaces',
-    indentSize: 2,
-    lineWidth: 120,
-    semicolons: true,
-    quotes: 'single',
-    trailingCommas: true,
-    sortImports: true,
-  };
-
-  constructor(config: FormatterConfig = {}) {
-    this.config = { ...this.defaultConfig, ...config };
-  }
-
-  /**
-   * Format code based on language
-   */
-  format(code: string, language: string): string {
-    switch (language.toLowerCase()) {
-      case 'typescript':
-      case 'ts':
-        return this.formatTypeScript(code);
-      case 'javascript':
-      case 'js':
-        return this.formatJavaScript(code);
-      case 'go':
-        return this.formatGo(code);
-      case 'python':
-      case 'py':
-        return this.formatPython(code);
-      default:
-        return this.formatGeneric(code);
-    }
-  }
-
-  /**
-   * Format TypeScript code
-   */
-  formatTypeScript(code: string): string {
-    let formatted = code;
-
-    // Sort imports if enabled
-    if (this.config.sortImports) {
-      formatted = this.sortImports(formatted);
-    }
-
-    // Normalize quotes
-    formatted = this.normalizeQuotes(formatted);
-
-    // Normalize spacing around braces
-    formatted = this.normalizeBraces(formatted);
-
-    // Fix common formatting issues
-    formatted = this.fixCommonIssues(formatted);
-
-    return formatted;
-  }
-
-  /**
-   * Format JavaScript code
-   */
-  formatJavaScript(code: string): string {
-    // Same as TypeScript for now
-    return this.formatTypeScript(code);
-  }
-
-  /**
-   * Format Go code
-   */
-  formatGo(code: string): string {
-    let formatted = code;
-
-    // Go uses tabs, normalize indentation
-    if (this.config.indentStyle === 'spaces') {
-      // Convert spaces to tabs for Go (Go convention)
-      formatted = formatted.replace(/^( {2,})/gm, (match) => {
-        return '\t'.repeat(match.length / 2);
-      });
-    }
-
-    // Remove trailing whitespace
-    formatted = formatted.replace(/[ \t]+$/gm, '');
-
-    // Ensure file ends with newline
-    if (!formatted.endsWith('\n')) {
-      formatted += '\n';
-    }
-
-    return formatted;
-  }
-
-  /**
-   * Format Python code
-   */
-  formatPython(code: string): string {
-    let formatted = code;
-
-    // Python uses 4 spaces by convention
-    // Normalize indentation to 4 spaces
-    formatted = this.normalizePythonIndentation(formatted);
-
-    // Remove trailing whitespace
-    formatted = formatted.replace(/[ \t]+$/gm, '');
-
-    // Ensure file ends with newline
-    if (!formatted.endsWith('\n')) {
-      formatted += '\n';
-    }
-
-    return formatted;
-  }
-
-  /**
-   * Generic formatting
-   */
-  formatGeneric(code: string): string {
-    let formatted = code;
-
-    // Remove trailing whitespace
-    formatted = formatted.replace(/[ \t]+$/gm, '');
-
-    // Ensure file ends with newline
-    if (!formatted.endsWith('\n')) {
-      formatted += '\n';
-    }
-
-    return formatted;
-  }
-
-  /**
-   * Validate code syntax
-   */
-  validate(code: string, language: string): FormatResult {
-    const errors: string[] = [];
-    const warnings: string[] = [];
-
-    // Check for common issues
-    if (!code.trim()) {
-      errors.push('Code is empty');
-    }
-
-    // Check for balanced braces
-    const openBraces = (code.match(/\{/g) || []).length;
-    const closeBraces = (code.match(/\}/g) || []).length;
-    if (openBraces !== closeBraces) {
-      errors.push(`Unbalanced braces: ${openBraces} open, ${closeBraces} close`);
-    }
-
-    // Check for balanced parentheses
-    const openParens = (code.match(/\(/g) || []).length;
-    const closeParens = (code.match(/\)/g) || []).length;
-    if (openParens !== closeParens) {
-      errors.push(`Unbalanced parentheses: ${openParens} open, ${closeParens} close`);
-    }
-
-    // Check for balanced brackets
-    const openBrackets = (code.match(/\[/g) || []).length;
-    const closeBrackets = (code.match(/\]/g) || []).length;
-    if (openBrackets !== closeBrackets) {
-      errors.push(`Unbalanced brackets: ${openBrackets} open, ${closeBrackets} close`);
-    }
-
-    // Language-specific checks
-    if (language === 'typescript' || language === 'javascript') {
-      // Check for TODO comments
-      const todos = code.match(/TODO|FIXME|XXX/gi);
-      if (todos) {
-        warnings.push(`Found ${todos.length} TODO/FIXME comments`);
-      }
-
-      // Check for console.log
-      const consoleLogs = code.match(/console\.log/g);
-      if (consoleLogs && consoleLogs.length > 2) {
-        warnings.push(`Found ${consoleLogs.length} console.log statements`);
-      }
-
-      // Check for any declarations
-      if (code.includes(' any')) {
-        warnings.push('Using "any" type - consider specific types');
-      }
-    }
-
-    return {
-      formatted: this.format(code, language),
-      errors,
-      warnings,
-    };
-  }
-
-  /**
-   * Sort imports
-   */
-  private sortImports(code: string): string {
-    const lines = code.split('\n');
-    const importSection: string[] = [];
-    const rest: string[] = [];
-    let inImports = false;
-    let afterImports = false;
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-
-      if (trimmed.startsWith('import ')) {
-        inImports = true;
-        importSection.push(line);
-      } else if (inImports && (trimmed.startsWith('//') || trimmed === '')) {
-        importSection.push(line);
-      } else {
-        if (inImports) {
-          afterImports = true;
-        }
-        inImports = false;
-        rest.push(line);
-      }
-    }
-
-    // Sort imports alphabetically
-    const sortedImports = this.sortImportLines(importSection);
-
-    return [...sortedImports, ...rest].join('\n');
-  }
-
-  /**
-   * Sort import lines
-   */
-  private sortImportLines(importLines: string[]): string[] {
-    // Separate by type: npm imports, relative imports, blank lines/comments
-    const npmImports: string[] = [];
-    const relativeImports: string[] = [];
-    const others: string[] = [];
-
-    for (const line of importLines) {
-      const trimmed = line.trim();
-
-      if (trimmed.startsWith('//') || trimmed === '') {
-        others.push(line);
-      } else if (trimmed.includes("from '")) {
-        const fromMatch = trimmed.match(/from\s+['"]([^'"]+)['"]/);
-        if (fromMatch) {
-          const from = fromMatch[1];
-          if (from.startsWith('.') || from.startsWith('/')) {
-            relativeImports.push(line);
-          } else {
-            npmImports.push(line);
-          }
-        }
-      } else {
-        others.push(line);
-      }
-    }
-
-    // Sort each group
-    npmImports.sort();
-    relativeImports.sort();
-
-    return [...others, ...npmImports, ...relativeImports];
-  }
-
-  /**
-   * Normalize quotes
-   */
-  private normalizeQuotes(code: string): string {
-    if (this.config.quotes === 'single') {
-      // Replace double quotes with single (except for escaped quotes)
-      return code.replace(/"([^"\\]*(\\.[^"\\]*)*)"/g, (_, content) => {
-        // Check if there are escaped single quotes inside
-        if (content.includes("\\'")) {
-          return `"${content}"`;
-        }
-        return `'${content.replace(/"/g, '\\"')}'`;
-      });
-    } else {
-      // Replace single quotes with double
-      return code.replace(/'([^'\\]*(\\.[^'\\]*)*)'/g, (_, content) => {
-        if (content.includes('\\"')) {
-          return `'${content}'`;
-        }
-        return `"${content.replace(/'/g, "\\'")}"`;
-      });
-    }
-  }
-
-  /**
-   * Normalize braces spacing
-   */
-  private normalizeBraces(code: string): string {
-    // Ensure consistent spacing around braces
-    // Function declarations: function name() {
-    code = code.replace(/\s*\{\s*/g, ' {\n');
-    code = code.replace(/\s*\}\s*/g, '\n}\n');
-
-    return code;
-  }
-
-  /**
-   * Fix common formatting issues
-   */
-  private fixCommonIssues(code: string): string {
-    let fixed = code;
-
-    // Remove multiple consecutive blank lines
-    fixed = fixed.replace(/\n{3,}/g, '\n\n');
-
-    // Remove trailing whitespace
-    fixed = fixed.replace(/[ \t]+$/gm, '');
-
-    // Ensure file ends with newline
-    if (!fixed.endsWith('\n')) {
-      fixed += '\n';
-    }
-
-    return fixed;
-  }
-
-  /**
-   * Normalize Python indentation
-   */
-  private normalizePythonIndentation(code: string): string {
-    const lines = code.split('\n');
-    const result: string[] = [];
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed === '') {
-        result.push('');
-        continue;
-      }
-
-      // Count leading spaces
-      const leadingSpaces = line.match(/^(\s*)/)?.[0]?.length || 0;
-      const indentLevel = Math.ceil(leadingSpaces / 2);
-
-      // Python uses 4 spaces per indent level
-      result.push(' '.repeat(indentLevel * 4) + trimmed);
-    }
-
-    return result.join('\n');
-  }
-}
-
-/**
- * Create a formatter with default config
- */
-export function createFormatter(config?: FormatterConfig): CodeFormatter {
-  return new CodeFormatter(config);
-}