qa360 2.1.7 → 2.2.0

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

@@ -0,0 +1,488 @@
+/**
+ * Selector Healer
+ *
+ * Intelligently heals broken CSS selectors in UI/E2E tests.
+ * Uses multiple strategies to find replacement selectors.
+ */
+
+import type {
+  SelectorHealingResult,
+  SelectorHealingStrategy,
+  SelectorErrorType,
+  SelfHealingConfig
+} from './types.js';
+
+/**
+ * Configuration for selector healing
+ */
+interface SelectorHealOptions {
+  /** Page URL where selector failed */
+  pageUrl?: string;
+
+  /** DOM snapshot at time of failure */
+  domSnapshot?: {
+    title: string;
+    url: string;
+    html?: string;
+    elements: Record<string, number>;
+  };
+
+  /** Error type that occurred */
+  errorType?: SelectorErrorType;
+
+  /** Original selector that failed */
+  originalSelector: string;
+
+  /** Expected element type (button, input, etc.) */
+  expectedType?: string;
+
+  /** Text content the element should have */
+  expectedText?: string;
+
+  /** Confidence threshold for healing */
+  confidenceThreshold?: number;
+}
+
+/**
+ * Candidate replacement selector
+ */
+interface SelectorCandidate {
+  selector: string;
+  strategy: SelectorHealingStrategy;
+  confidence: number;
+  reason: string;
+}
+
+/**
+ * Selector Healer class
+ */
+export class SelectorHealer {
+  private config: SelfHealingConfig;
+
+  constructor(config: SelfHealingConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Attempt to heal a broken selector
+   */
+  async healSelector(options: SelectorHealOptions): Promise<SelectorHealingResult> {
+    const candidates: SelectorCandidate[] = [];
+
+    // Try each enabled strategy
+    if (this.config.features.selectorHealing) {
+      if (this.config.selectorStrategies.useDataTestIds) {
+        candidates.push(...this.tryDataTestIdStrategies(options));
+      }
+
+      if (this.config.selectorStrategies.useAriaLabels) {
+        candidates.push(...this.tryAriaLabelStrategies(options));
+      }
+
+      if (this.config.selectorStrategies.useTextSelectors) {
+        candidates.push(...this.tryTextContentStrategies(options));
+      }
+
+      if (this.config.selectorStrategies.fuzzyMatching) {
+        candidates.push(...this.tryFuzzyMatchStrategies(options));
+      }
+    }
+
+    // Sort by confidence and return best candidate
+    candidates.sort((a, b) => b.confidence - a.confidence);
+
+    const best = candidates[0];
+
+    if (best && best.confidence >= (this.config.confidenceThreshold || 0.7)) {
+      return {
+        originalSelector: options.originalSelector,
+        healedSelector: best.selector,
+        strategy: best.strategy,
+        confidence: best.confidence,
+        elementCount: 1,
+        failureReason: this.inferFailureReason(options.errorType)
+      };
+    }
+
+    // No good heal found
+    return {
+      originalSelector: options.originalSelector,
+      healedSelector: options.originalSelector,
+      strategy: 'no_heal',
+      confidence: 0,
+      elementCount: 0,
+      failureReason: this.inferFailureReason(options.errorType)
+    };
+  }
+
+  /**
+   * Try data-testid attribute strategies
+   */
+  private tryDataTestIdStrategies(options: SelectorHealOptions): SelectorCandidate[] {
+    const candidates: SelectorCandidate[] = [];
+    const { originalSelector, expectedText } = options;
+
+    // Extract potential test ID from original selector
+    const idMatch = originalSelector.match(/#(\w+)/);
+    const classMatch = originalSelector.match(/\.([\w-]+)/);
+    const tagMatch = originalSelector.match(/^(\w+)/);
+
+    // Strategy 1: Convert ID to data-testid
+    if (idMatch) {
+      const testId = idMatch[1];
+      candidates.push({
+        selector: `[data-testid="${testId}"]`,
+        strategy: 'data_testid',
+        confidence: 0.85,
+        reason: 'Converted ID to data-testid attribute'
+      });
+    }
+
+    // Strategy 2: Convert class to data-testid
+    if (classMatch) {
+      const testId = classMatch[1].replace(/-/g, '_');
+      candidates.push({
+        selector: `[data-testid="${testId}"]`,
+        strategy: 'data_testid',
+        confidence: 0.75,
+        reason: 'Converted class name to data-testid attribute'
+      });
+    }
+
+    // Strategy 3: Generate data-testid from expected text
+    if (expectedText) {
+      const testId = expectedText
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+
+      candidates.push({
+        selector: `[data-testid="${testId}"]`,
+        strategy: 'data_testid',
+        confidence: 0.70,
+        reason: 'Generated data-testid from expected text'
+      });
+    }
+
+    // Strategy 4: Tag-based data-testid
+    if (tagMatch) {
+      const tag = tagMatch[1];
+      candidates.push({
+        selector: `${tag}[data-testid]`,
+        strategy: 'data_testid',
+        confidence: 0.60,
+        reason: 'Tag with any data-testid attribute'
+      });
+    }
+
+    return candidates;
+  }
+
+  /**
+   * Try ARIA label strategies
+   */
+  private tryAriaLabelStrategies(options: SelectorHealOptions): SelectorCandidate[] {
+    const candidates: SelectorCandidate[] = [];
+    const { originalSelector, expectedText } = options;
+
+    // Extract tag if available
+    const tagMatch = originalSelector.match(/^(\w+)/);
+    const tag = tagMatch ? `${tagMatch[1]}[` : '[';
+
+    // Strategy 1: Use expected text as aria-label
+    if (expectedText) {
+      const escapedText = this.escapeCssString(expectedText);
+      candidates.push({
+        selector: `${tag}aria-label="${escapedText}"]`,
+        strategy: 'aria_label',
+        confidence: 0.80,
+        reason: 'Match by aria-label attribute'
+      });
+    }
+
+    // Strategy 2: Role-based selectors
+    const roleMap: Record<string, string> = {
+      'button': 'button',
+      'input': 'textbox',
+      'select': 'combobox',
+      'a': 'link',
+    };
+
+    if (tagMatch) {
+      const tagName = tagMatch[1];
+      const role = roleMap[tagName];
+      if (role) {
+        candidates.push({
+          selector: `[role="${role}"]`,
+          strategy: 'aria_label',
+          confidence: 0.60,
+          reason: `Match by ARIA role for <${tagName}> element`
+        });
+      }
+    }
+
+    return candidates;
+  }
+
+  /**
+   * Try text content strategies
+   */
+  private tryTextContentStrategies(options: SelectorHealOptions): SelectorCandidate[] {
+    const candidates: SelectorCandidate[] = [];
+    const { originalSelector, expectedText } = options;
+
+    if (!expectedText) {
+      return candidates;
+    }
+
+    // Strategy 1: Playwright text selector
+    candidates.push({
+      selector: `text="${expectedText}"`,
+      strategy: 'text_content',
+      confidence: 0.75,
+      reason: 'Exact text match'
+    });
+
+    // Strategy 2: XPath text selector
+    const xpathText = this.escapeXPathString(expectedText);
+    candidates.push({
+      selector: `xpath=.//*[text()="${xpathText}"]`,
+      strategy: 'text_content',
+      confidence: 0.72,
+      reason: 'XPath text match'
+    });
+
+    // Strategy 3: Combine with tag if available
+    const tagMatch = originalSelector.match(/^(\w+)/);
+    if (tagMatch) {
+      const tag = tagMatch[1];
+      candidates.push({
+        selector: `${tag}:has-text("${expectedText}")`,
+        strategy: 'text_content',
+        confidence: 0.70,
+        reason: `Tag with text content: ${tag}`
+      });
+    }
+
+    return candidates;
+  }
+
+  /**
+   * Try fuzzy matching strategies
+   */
+  private tryFuzzyMatchStrategies(options: SelectorHealOptions): SelectorCandidate[] {
+    const candidates: SelectorCandidate[] = [];
+    const { originalSelector } = options;
+
+    // Strategy 1: Remove pseudo-classes
+    const withoutPseudo = originalSelector.replace(/::?[a-z-]+(\([^)]*\))?/gi, '');
+    if (withoutPseudo !== originalSelector) {
+      candidates.push({
+        selector: withoutPseudo,
+        strategy: 'fuzzy_match',
+        confidence: 0.65,
+        reason: 'Removed pseudo-classes'
+      });
+    }
+
+    // Strategy 2: Try nth-child variants
+    const nthMatch = originalSelector.match(/:nth-child\((\d+)\)/);
+    if (nthMatch) {
+      const index = parseInt(nthMatch[1], 10);
+      const baseSelector = originalSelector.replace(/:nth-child\(\d+\)/, '');
+
+      // Try nth-of-type
+      candidates.push({
+        selector: `${baseSelector}:nth-of-type(${index})`,
+        strategy: 'fuzzy_match',
+        confidence: 0.55,
+        reason: 'Changed nth-child to nth-of-type'
+      });
+
+      // Try first/last
+      if (index === 1) {
+        candidates.push({
+          selector: `${baseSelector}:first-child`,
+          strategy: 'fuzzy_match',
+          confidence: 0.60,
+          reason: 'Changed nth-child(1) to first-child'
+        });
+      }
+    }
+
+    // Strategy 3: Try removing one selector component at a time
+    const parts = originalSelector.split(/\s+/);
+    if (parts.length > 1) {
+      // Try without the last part
+      candidates.push({
+        selector: parts.slice(0, -1).join(' '),
+        strategy: 'fuzzy_match',
+        confidence: 0.45,
+        reason: 'Removed last selector component'
+      });
+    }
+
+    return candidates;
+  }
+
+  /**
+   * Infer failure reason from error type
+   */
+  private inferFailureReason(errorType?: SelectorErrorType): string {
+    const reasons: Record<SelectorErrorType, string> = {
+      timeout: 'Element not found within timeout period',
+      not_found: 'No matching elements found in DOM',
+      ambiguous: 'Multiple elements matched - selector not specific enough',
+      detached: 'Element was detached from DOM',
+      invisible: 'Element exists but not visible or interactable',
+      stale: 'Element reference became stale'
+    };
+
+    return errorType ? reasons[errorType] : 'Unknown selector failure';
+  }
+
+  /**
+   * Escape string for CSS selectors
+   */
+  private escapeCssString(str: string): string {
+    return str.replace(/(["\\])/g, '\\$1');
+  }
+
+  /**
+   * Escape string for XPath
+   */
+  private escapeXPathString(str: string): string {
+    if (str.includes('"')) {
+      if (str.includes("'")) {
+        // Use concat for strings with both quotes
+        return str
+          .split(/(")/)
+          .map(part => {
+            if (part === '"') return '\'"\''; // '"'"' concat hack
+            if (part === "'") return "'";
+            return `"${part}"`;
+          })
+          .join(', ');
+      }
+      return `'${str}'`;
+    }
+    return `"${str}"`;
+  }
+
+  /**
+   * Parse selector to understand its structure
+   */
+  parseSelector(selector: string): {
+    tag?: string;
+    id?: string;
+    classes: string[];
+    attributes: Record<string, string>;
+    pseudoClasses: string[];
+    combinators: string[];
+  } {
+    const result: {
+      tag?: string;
+      id?: string;
+      classes: string[];
+      attributes: Record<string, string>;
+      pseudoClasses: string[];
+      combinators: string[];
+    } = {
+      classes: [],
+      attributes: {},
+      pseudoClasses: [],
+      combinators: []
+    };
+
+    // Extract tag
+    const tagMatch = selector.match(/^([\w-]+)/);
+    if (tagMatch) {
+      result.tag = tagMatch[1];
+    }
+
+    // Extract ID
+    const idMatch = selector.match(/#([\w-]+)/);
+    if (idMatch) {
+      result.id = idMatch[1];
+    }
+
+    // Extract classes
+    const classMatches = selector.matchAll(/\.([\w-]+)/g);
+    for (const match of classMatches) {
+      result.classes.push(match[1]);
+    }
+
+    // Extract attributes
+    const attrMatches = selector.matchAll(/\[([\w-]+)(=["']([^"']*)["'])?\]/g);
+    for (const match of attrMatches) {
+      result.attributes[match[1]] = match[3] || '';
+    }
+
+    return result;
+  }
+
+  /**
+   * Generate multiple healing candidates for a selector
+   */
+  async generateHealingCandidates(
+    selector: string,
+    context?: Pick<SelectorHealOptions, 'expectedText' | 'errorType'>
+  ): Promise<SelectorCandidate[]> {
+    const allCandidates: SelectorCandidate[] = [];
+    const options: SelectorHealOptions = {
+      originalSelector: selector,
+      expectedText: context?.expectedText,
+      errorType: context?.errorType
+    };
+
+    // Generate candidates from all strategies
+    allCandidates.push(...this.tryDataTestIdStrategies(options));
+    allCandidates.push(...this.tryAriaLabelStrategies(options));
+    allCandidates.push(...this.tryTextContentStrategies(options));
+    allCandidates.push(...this.tryFuzzyMatchStrategies(options));
+
+    // Remove duplicates and sort by confidence
+    const unique = this.deduplicateCandidates(allCandidates);
+    unique.sort((a, b) => b.confidence - a.confidence);
+
+    return unique;
+  }
+
+  /**
+   * Remove duplicate candidates
+   */
+  private deduplicateCandidates(candidates: SelectorCandidate[]): SelectorCandidate[] {
+    const seen = new Set<string>();
+    return candidates.filter(c => {
+      if (seen.has(c.selector)) return false;
+      seen.add(c.selector);
+      return true;
+    });
+  }
+}
+
+/**
+ * Create a default self-healing config
+ */
+export function createDefaultSelfHealingConfig(): SelfHealingConfig {
+  return {
+    enabled: true,
+    maxAttempts: 3,
+    confidenceThreshold: 0.7,
+    autoApply: false,
+    backup: true,
+    features: {
+      selectorHealing: true,
+      assertionUpdates: true,
+      apiHealing: true,
+      timeoutAdjustment: true,
+      aiAssisted: true
+    },
+    selectorStrategies: {
+      useDataTestIds: true,
+      useAriaLabels: true,
+      useTextSelectors: true,
+      fuzzyMatching: true
+    }
+  };
+}

package/core/src/self-healing/types.ts

@@ -0,0 +1,193 @@
+/**
+ * QA360 Self-Healing Module
+ *
+ * Types for self-healing functionality.
+ */
+
+/**
+ * Self-healing configuration
+ */
+export interface SelfHealingConfig {
+  enabled: boolean;
+  maxAttempts: number;
+  confidenceThreshold: number;
+  autoApply: boolean;
+  backup: boolean;
+  features: {
+    selectorHealing: boolean;
+    assertionUpdates: boolean;
+    apiHealing: boolean;
+    timeoutAdjustment: boolean;
+    aiAssisted: boolean;
+  };
+  selectorStrategies: {
+    useDataTestIds: boolean;
+    useAriaLabels: boolean;
+    useTextSelectors: boolean;
+    fuzzyMatching: boolean;
+  };
+}
+
+/**
+ * Selector error types
+ */
+export type SelectorErrorType =
+  | 'timeout'
+  | 'not_found'
+  | 'ambiguous'
+  | 'detached'
+  | 'invisible'
+  | 'stale';
+
+/**
+ * Selector healing strategy types
+ */
+export type SelectorHealingStrategy =
+  | 'data_testid'
+  | 'aria_label'
+  | 'text_content'
+  | 'fuzzy_match'
+  | 'sibling_traversal'
+  | 'css_variant'
+  | 'ai_suggested'
+  | 'no_heal';
+
+/**
+ * Selector healing result
+ */
+export interface SelectorHealingResult {
+  originalSelector: string;
+  healedSelector: string;
+  strategy: SelectorHealingStrategy;
+  confidence: number;
+  elementCount: number;
+  failureReason: string;
+}
+
+/**
+ * Assertion types
+ */
+export type AssertionType =
+  | 'equality'
+  | 'containment'
+  | 'truthiness'
+  | 'count'
+  | 'status_code'
+  | 'response_body'
+  | 'ui_element_exists'
+  | 'ui_text_matches';
+
+/**
+ * Assertion update result
+ */
+export interface AssertionUpdateResult {
+  testFile: string;
+  lineNumber: number;
+  originalAssertion: string;
+  updatedAssertion: string;
+  expected: string;
+  actual: string;
+  confidence: number;
+  assertionType: AssertionType;
+}
+
+/**
+ * API change types
+ */
+export type ApiChangeType =
+  | 'path_changed'
+  | 'method_changed'
+  | 'status_changed'
+  | 'response_structure'
+  | 'auth_required'
+  | 'deprecated'
+  | 'moved_permanently';
+
+/**
+ * API healing result
+ */
+export interface ApiHealingResult {
+  originalSpec: string;
+  healedSpec: string;
+  changeType: ApiChangeType;
+  suggestion: string;
+  confidence: number;
+}
+
+/**
+ * Self-healing session result
+ */
+export interface SelfHealingSession {
+  sessionId: string;
+  startTime: number;
+  endTime: number;
+  duration: number;
+  config: SelfHealingConfig;
+  selectorHeals: SelectorHealingResult[];
+  assertionUpdates: AssertionUpdateResult[];
+  apiHeals: ApiHealingResult[];
+  success: boolean;
+  unhealed: number;
+  summary: SelfHealingSummary;
+}
+
+/**
+ * Self-healing summary statistics
+ */
+export interface SelfHealingSummary {
+  totalIssues: number;
+  healed: number;
+  failed: number;
+  highConfidence: number;
+  mediumConfidence: number;
+  lowConfidence: number;
+  byType: {
+    selector: number;
+    assertion: number;
+    api: number;
+    timeout: number;
+  };
+  successRate: number;
+}
+
+/**
+ * Test failure context for healing
+ */
+export interface TestFailureContext {
+  testType: 'api' | 'ui' | 'a11y' | 'perf' | 'unknown';
+  gate: string;
+  testSource: string;
+  errorMessage: string;
+  stackTrace?: string;
+  screenshot?: string;
+  pageUrl?: string;
+  domSnapshot?: {
+    title: string;
+    url: string;
+    html?: string;
+    elements: Record<string, number>;
+  };
+  requestDetails?: {
+    url: string;
+    method: string;
+    status?: number;
+    responseTime?: number;
+    responseBody?: unknown;
+  };
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * AI healing suggestion
+ */
+export interface AiHealingSuggestion {
+  code: string;
+  explanation: string;
+  filePath: string;
+  lineNumber: number;
+  confidence: number;
+  effort: 'low' | 'medium' | 'high';
+  healingType: 'selector' | 'assertion' | 'api' | 'timeout' | 'other';
+  applied?: boolean;
+  verified?: boolean;
+}