qa360 2.2.1 → 2.2.13

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

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

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