qa360 2.1.7 → 2.2.0

package/dist/core/self-healing/selector-healer.js

@@ -1,372 +0,0 @@
-/**
- * Selector Healer
- *
- * Intelligently heals broken CSS selectors in UI/E2E tests.
- * Uses multiple strategies to find replacement selectors.
- */
-/**
- * Selector Healer class
- */
-export class SelectorHealer {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    /**
-     * Attempt to heal a broken selector
-     */
-    async healSelector(options) {
-        const candidates = [];
-        // 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
-     */
-    tryDataTestIdStrategies(options) {
-        const candidates = [];
-        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
-     */
-    tryAriaLabelStrategies(options) {
-        const candidates = [];
-        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 = {
-            '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
-     */
-    tryTextContentStrategies(options) {
-        const candidates = [];
-        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
-     */
-    tryFuzzyMatchStrategies(options) {
-        const candidates = [];
-        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
-     */
-    inferFailureReason(errorType) {
-        const reasons = {
-            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
-     */
-    escapeCssString(str) {
-        return str.replace(/(["\\])/g, '\\$1');
-    }
-    /**
-     * Escape string for XPath
-     */
-    escapeXPathString(str) {
-        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) {
-        const result = {
-            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, context) {
-        const allCandidates = [];
-        const options = {
-            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
-     */
-    deduplicateCandidates(candidates) {
-        const seen = new Set();
-        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() {
-    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/dist/core/self-healing/types.d.ts

@@ -1,152 +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;
-}

package/dist/core/self-healing/types.js

@@ -1,6 +0,0 @@
-/**
- * QA360 Self-Healing Module
- *
- * Types for self-healing functionality.
- */
-export {};

package/dist/core/serve/diagnostics-collector.d.ts

@@ -1,32 +0,0 @@
-/**
- * QA360 Diagnostics Collector
- * Collecte des diagnostics actionnables pour /diag
- */
-export interface DiagnosticProblem {
-    code: string;
-    title: string;
-    fix: string;
-}
-export interface DiagnosticSuggestion {
-    message: string;
-}
-export interface LastRun {
-    runId: string;
-    trust: number;
-    ts: string;
-    status?: 'success' | 'failed' | 'cancelled';
-}
-export interface DiagnosticsReport {
-    problems: DiagnosticProblem[];
-    suggestions: string[];
-    last_runs: LastRun[];
-}
-export declare class DiagnosticsCollector {
-    private healthChecker;
-    constructor();
-    collect(): Promise<DiagnosticsReport>;
-    private analyzeProblems;
-    private generateSuggestions;
-    private getLastRuns;
-    private inferRunStatus;
-}