qa360 2.1.2 → 2.1.4

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

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

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