qa360 2.1.2 → 2.1.4

package/core/src/self-healing/assertion-healer.ts

@@ -0,0 +1,485 @@
+/**
+ * Assertion Healer
+ *
+ * Intelligently heals broken assertions in tests.
+ * Supports Jest, Chai, and Node.js assert styles.
+ */
+
+import type {
+  AssertionUpdateResult,
+  AssertionType,
+  SelfHealingConfig
+} from './types.js';
+
+/**
+ * Parsed assertion information
+ */
+interface ParsedAssertion {
+  type: AssertionType;
+  originalAssertion?: string;
+  actual: string;
+  expected: string;
+  negated: boolean;
+  matcher?: string;
+  line: number;
+  column: number;
+}
+
+/**
+ * Assertion healing options
+ */
+interface AssertionHealOptions {
+  /** Test file content */
+  fileContent: string;
+
+  /** Line number of failed assertion */
+  lineNumber: number;
+
+  /** Expected value */
+  expected: string;
+
+  /** Actual value received */
+  actual: string;
+
+  /** Error message from failure */
+  errorMessage?: string;
+
+  /** Test framework (jest, chai, assert) */
+  framework?: 'jest' | 'chai' | 'assert' | 'auto';
+}
+
+/**
+ * Assertion Healer class
+ */
+export class AssertionHealer {
+  private config: SelfHealingConfig;
+
+  constructor(config: SelfHealingConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Attempt to heal a broken assertion
+   */
+  async healAssertion(options: AssertionHealOptions): Promise<AssertionUpdateResult | null> {
+    if (!this.config.features.assertionUpdates) {
+      return null;
+    }
+
+    const parsed = this.parseAssertion(options);
+    if (!parsed) {
+      return null;
+    }
+
+    // Determine if healing is possible
+    const confidence = this.calculateHealingConfidence(parsed, options);
+
+    if (confidence < (this.config.confidenceThreshold || 0.7)) {
+      return null;
+    }
+
+    // Generate healed assertion
+    const updatedAssertion = this.generateHealedAssertion(parsed, options);
+
+    return {
+      testFile: '', // Caller should fill this
+      lineNumber: options.lineNumber,
+      originalAssertion: parsed.originalAssertion || '',
+      updatedAssertion,
+      expected: options.expected,
+      actual: options.actual,
+      confidence,
+      assertionType: parsed.type
+    };
+  }
+
+  /**
+   * Parse the assertion from file content
+   */
+  private parseAssertion(options: AssertionHealOptions): ParsedAssertion | null {
+    const lines = options.fileContent.split('\n');
+    const line = lines[options.lineNumber - 1];
+
+    if (!line) {
+      return null;
+    }
+
+    const framework = options.framework === 'auto' ? this.detectFramework(options.fileContent) : options.framework;
+
+    switch (framework) {
+      case 'jest':
+        return this.parseJestAssertion(line, options);
+      case 'chai':
+        return this.parseChaiAssertion(line, options);
+      case 'assert':
+        return this.parseAssertAssertion(line, options);
+      default:
+        // Try all parsers
+        return (
+          this.parseJestAssertion(line, options) ||
+          this.parseChaiAssertion(line, options) ||
+          this.parseAssertAssertion(line, options)
+        );
+    }
+  }
+
+  /**
+   * Detect test framework from file content
+   */
+  private detectFramework(content: string): 'jest' | 'chai' | 'assert' {
+    const hasJest = /\b(expect|describe|it|test)\(/.test(content);
+    const hasChai = /\b(expect|should)\./.test(content) && /\b(chai|assert)\b/.test(content);
+    const hasAssert = /\b(require\(['"]assert['"]\)|import.*assert)\b/.test(content);
+
+    if (hasJest && !hasChai) return 'jest';
+    if (hasChai) return 'chai';
+    if (hasAssert) return 'assert';
+    return 'jest'; // Default
+  }
+
+  /**
+   * Parse Jest-style assertion
+   */
+  private parseJestAssertion(line: string, options: AssertionHealOptions): ParsedAssertion | null {
+    const jestPattern = /expect\(([^)]+)\)\.\s*(not\.)?(to[\w]+)\(([^)]*)\)/;
+    const match = line.match(jestPattern);
+
+    if (!match) {
+      return null;
+    }
+
+    const [, actual, negated, matcher, expected] = match;
+    const type = this.mapJestMatcherToType(matcher);
+
+    return {
+      type,
+      originalAssertion: line.trim(),
+      actual: actual.trim(),
+      expected: expected.trim() || options.expected,
+      negated: !!negated,
+      matcher,
+      line: options.lineNumber,
+      column: line.indexOf(match[0]) + 1
+    };
+  }
+
+  /**
+   * Parse Chai-style assertion
+   */
+  private parseChaiAssertion(line: string, options: AssertionHealOptions): ParsedAssertion | null {
+    // expect(actual).to/match/have.property
+    const expectPattern = /expect\(([^)]+)\)\.\s*(to|should)\.\s*(not\.)?([\w.]+)\(([^)]*)\)/;
+    let match = line.match(expectPattern);
+
+    if (match) {
+      const [, actual, , negated, matcher, expected] = match;
+      const type = this.mapChaiMatcherToType(matcher);
+
+      return {
+        type,
+        originalAssertion: line.trim(),
+        actual: actual.trim(),
+        expected: expected.trim() || options.expected,
+        negated: !!negated,
+        matcher,
+        line: options.lineNumber,
+        column: line.indexOf(match[0]) + 1
+      };
+    }
+
+    // should style
+    const shouldPattern = /([\w.]+)\.should\.\s*(not\.)?([\w.]+)\(([^)]*)\)/;
+    match = line.match(shouldPattern);
+
+    if (match) {
+      const [, actual, negated, matcher, expected] = match;
+      const type = this.mapChaiMatcherToType(matcher);
+
+      return {
+        type,
+        originalAssertion: line.trim(),
+        actual: actual.trim(),
+        expected: expected.trim() || options.expected,
+        negated: !!negated,
+        matcher,
+        line: options.lineNumber,
+        column: line.indexOf(match[0]) + 1
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Parse Node.js assert-style assertion
+   */
+  private parseAssertAssertion(line: string, options: AssertionHealOptions): ParsedAssertion | null {
+    // assert.strictEqual(actual, expected)
+    const strictEqualPattern = /assert\.(strictEqual|deepStrictEqual|equal)\(([^,]+),\s*([^)]+)\)/;
+    let match = line.match(strictEqualPattern);
+
+    if (match) {
+      const [, method, actual, expected] = match;
+      return {
+        type: 'equality',
+        originalAssertion: line.trim(),
+        actual: actual.trim(),
+        expected: expected.trim(),
+        negated: false,
+        matcher: method,
+        line: options.lineNumber,
+        column: line.indexOf(match[0]) + 1
+      };
+    }
+
+    // assert actual, expected
+    const simplePattern = new RegExp('^(assert\\.\\w+\\([^,]+),\\s*)');
+    const simpleMatch = line.match(simplePattern);
+
+    if (simpleMatch) {
+      return {
+        type: 'equality',
+        originalAssertion: line.trim(),
+        actual: simpleMatch[1],
+        expected: options.expected,
+        negated: false,
+        matcher: 'assert',
+        line: options.lineNumber,
+        column: 1
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * Map Jest matcher to assertion type
+   */
+  private mapJestMatcherToType(matcher: string): AssertionType {
+    const matcherMap: Record<string, AssertionType> = {
+      'toBe': 'equality',
+      'toEqual': 'equality',
+      'toStrictEqual': 'equality',
+      'toBeGreaterThan': 'count',
+      'toBeGreaterThanOrEqual': 'count',
+      'toBeLessThan': 'count',
+      'toBeLessThanOrEqual': 'count',
+      'toContain': 'containment',
+      'toContainEqual': 'containment',
+      'toMatch': 'containment',
+      'toMatchObject': 'containment',
+      'toBeTruthy': 'truthiness',
+      'toBeFalsy': 'truthiness',
+      'toBeNull': 'truthiness',
+      'toBeUndefined': 'truthiness',
+      'toBeDefined': 'truthiness',
+      'toHaveLength': 'count',
+      'toHaveProperty': 'containment'
+    };
+
+    return matcherMap[matcher] || 'equality';
+  }
+
+  /**
+   * Map Chai matcher to assertion type
+   */
+  private mapChaiMatcherToType(matcher: string): AssertionType {
+    const matcherMap: Record<string, AssertionType> = {
+      'equal': 'equality',
+      'deep.equal': 'equality',
+      'eql': 'equality',
+      'above': 'count',
+      'least': 'count',
+      'below': 'count',
+      'most': 'count',
+      'include': 'containment',
+      'contain': 'containment',
+      'contains': 'containment',
+      'match': 'containment',
+      'property': 'containment',
+      'true': 'truthiness',
+      'false': 'truthiness',
+      'null': 'truthiness',
+      'undefined': 'truthiness',
+      'exist': 'truthiness',
+      'empty': 'truthiness',
+      'lengthOf': 'count'
+    };
+
+    return matcherMap[matcher] || 'equality';
+  }
+
+  /**
+   * Calculate confidence for healing
+   */
+  private calculateHealingConfidence(
+    parsed: ParsedAssertion,
+    options: AssertionHealOptions
+  ): number {
+    let confidence = 0.5;
+
+    // Type-specific adjustments
+    if (parsed.type === 'equality') {
+      // Simple value changes are high confidence
+      const diffScore = this.calculateStringSimilarity(options.expected, options.actual);
+      confidence = Math.max(confidence, diffScore * 0.9);
+    }
+
+    if (parsed.type === 'containment') {
+      // Adding missing items is medium-high confidence
+      confidence = 0.75;
+    }
+
+    if (parsed.type === 'count') {
+      // Adjusting numbers is high confidence
+      const expectedNum = parseInt(options.expected, 10);
+      const actualNum = parseInt(options.actual, 10);
+      if (!isNaN(expectedNum) && !isNaN(actualNum)) {
+        confidence = 0.85;
+      }
+    }
+
+    // Adjust for negation
+    if (parsed.negated) {
+      confidence *= 0.8; // Lower confidence for negated assertions
+    }
+
+    // Adjust for error message clarity
+    if (options.errorMessage) {
+      if (options.errorMessage.includes('Expected:') && options.errorMessage.includes('Received:')) {
+        confidence += 0.1;
+      }
+    }
+
+    return Math.min(confidence, 1.0);
+  }
+
+  /**
+   * Generate healed assertion
+   */
+  private generateHealedAssertion(
+    parsed: ParsedAssertion,
+    options: AssertionHealOptions
+  ): string {
+    const actualValue = this.formatValue(options.actual);
+    const expectedValue = this.formatValue(options.expected);
+
+    if (parsed.matcher?.includes('toBe') || parsed.matcher === 'equal') {
+      // Jest: expect(actual).toBe(expected)
+      // Chai: expect(actual).to.equal(expected)
+      const isJest = parsed.matcher?.startsWith('to');
+      const separator = isJest ? `.${parsed.matcher}(` : `.to.${parsed.matcher}(`;
+      return `expect(${parsed.actual}).${parsed.negated ? 'not.' : ''}${separator}${expectedValue})`;
+    }
+
+    if (parsed.matcher?.includes('Equal') || parsed.matcher === 'deep.equal' || parsed.matcher === 'eql') {
+      return `expect(${parsed.actual})${parsed.negated ? '.not.' : '.'}${parsed.matcher || 'toEqual'}(${expectedValue})`;
+    }
+
+    if (parsed.matcher?.includes('Contain') || parsed.matcher?.includes('include')) {
+      return `expect(${parsed.actual})${parsed.negated ? '.not.' : '.'}${parsed.matcher || 'toContain'}(${expectedValue})`;
+    }
+
+    // Default: update expected value in original
+    let result = parsed.originalAssertion || '';
+
+    // Replace the expected value
+    const lastComma = result.lastIndexOf(',');
+    if (lastComma !== -1) {
+      result = result.substring(0, lastComma + 1) + ' ' + expectedValue + result.substring(result.lastIndexOf(')'));
+    }
+
+    return result;
+  }
+
+  /**
+   * Format a value for use in code
+   */
+  private formatValue(value: string): string {
+    // Try to detect if it's already formatted
+    if (/^['"`{[\[]/.test(value)) {
+      return value;
+    }
+
+    // Numbers
+    if (/^\d+$/.test(value)) {
+      return value;
+    }
+
+    // Booleans
+    if (value === 'true' || value === 'false') {
+      return value;
+    }
+
+    // Null/undefined
+    if (value === 'null' || value === 'undefined') {
+      return value;
+    }
+
+    // Default: treat as string
+    return JSON.stringify(value);
+  }
+
+  /**
+   * Calculate similarity between two strings (Levenshtein-based)
+   */
+  private calculateStringSimilarity(str1: string, str2: string): number {
+    const len1 = str1.length;
+    const len2 = str2.length;
+
+    if (len1 === 0) return len2 === 0 ? 1 : 0;
+    if (len2 === 0) return 0;
+
+    const matrix: number[][] = [];
+    for (let i = 0; i <= len1; i++) {
+      matrix[i] = [i];
+    }
+    for (let j = 0; j <= len2; j++) {
+      matrix[0][j] = j;
+    }
+
+    for (let i = 1; i <= len1; i++) {
+      for (let j = 1; j <= len2; j++) {
+        const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j - 1] + cost
+        );
+      }
+    }
+
+    const maxLen = Math.max(len1, len2);
+    return 1 - matrix[len1][len2] / maxLen;
+  }
+
+  /**
+   * Parse multiple assertions from a file
+   */
+  parseAssertionsFromFile(content: string): ParsedAssertion[] {
+    const assertions: ParsedAssertion[] = [];
+    const lines = content.split('\n');
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const options: AssertionHealOptions = {
+        fileContent: content,
+        lineNumber: i + 1,
+        expected: '',
+        actual: '',
+        framework: 'auto'
+      };
+
+      const parsed =
+        this.parseJestAssertion(line, options) ||
+        this.parseChaiAssertion(line, options) ||
+        this.parseAssertAssertion(line, options);
+
+      if (parsed) {
+        assertions.push(parsed);
+      }
+    }
+
+    return assertions;
+  }
+}