qa360 1.4.5 → 2.0.1

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

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

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

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

package/dist/core/slo/config.d.ts

@@ -0,0 +1,107 @@
+/**
+ * SLO/SLI Default Configuration
+ *
+ * Predefined SLOs and SLIs for common quality metrics.
+ * Factory functions for creating standard configurations.
+ */
+import type { SLO, SLI, SLOConfig } from './types.js';
+/**
+ * Default time windows in milliseconds
+ */
+export declare const TimeWindows: {
+    HOUR: number;
+    DAY: number;
+    WEEK: number;
+    MONTH: number;
+    QUARTER: number;
+};
+/**
+ * Create default SLO configuration
+ */
+export declare function createDefaultSLOConfig(): SLOConfig;
+/**
+ * Create strict SLO configuration (enterprise/production)
+ */
+export declare function createStrictSLOConfig(): SLOConfig;
+/**
+ * Create relaxed SLO configuration (development)
+ */
+export declare function createRelaxedSLOConfig(): SLOConfig;
+/**
+ * Default: Test Quality SLO (95% pass rate over 30 days)
+ */
+export declare function createDefaultTestQualitySLO(): SLO;
+/**
+ * Default: API Success Rate SLO (99.9% over 30 days)
+ */
+export declare function createDefaultAPISuccessSLO(): SLO;
+/**
+ * Default: Performance SLO (p95 latency < 500ms)
+ */
+export declare function createDefaultPerformanceSLO(): SLO;
+/**
+ * Strict: Test Quality SLO (98% pass rate)
+ */
+export declare function createStrictTestQualitySLO(): SLO;
+/**
+ * Strict: API Success Rate SLO (99.95%)
+ */
+export declare function createStrictAPISuccessSLO(): SLO;
+/**
+ * Strict: Performance SLO (p95 latency < 200ms)
+ */
+export declare function createStrictPerformanceSLO(): SLO;
+/**
+ * Relaxed: Test Quality SLO (90% pass rate)
+ */
+export declare function createRelaxedTestQualitySLO(): SLO;
+/**
+ * Relaxed: API Success Rate SLO (99%)
+ */
+export declare function createRelaxedAPISuccessSLO(): SLO;
+/**
+ * Relaxed: Performance SLO (p95 latency < 1000ms)
+ */
+export declare function createRelaxedPerformanceSLO(): SLO;
+/**
+ * SLI: Test Pass Rate
+ */
+export declare function createTestPassRateSLI(): SLI;
+/**
+ * SLI: API Success Rate
+ */
+export declare function createAPISuccessRateSLI(): SLI;
+/**
+ * SLI: Latency (p95)
+ */
+export declare function createLatencySLI(): SLI;
+/**
+ * Create custom SLO from parameters
+ */
+export declare function createCustomSLO(params: {
+    name: string;
+    description?: string;
+    target: number;
+    windowMs?: number;
+    sliIds: string[];
+    tags?: string[];
+    owner?: string;
+}): SLO;
+/**
+ * Create custom SLI from parameters
+ */
+export declare function createCustomSLI(params: {
+    name: string;
+    description?: string;
+    type: SLI['type'];
+    source: SLI['source'];
+    queryString: string;
+    aggregation: SLI['aggregation'];
+    unit: SLI['unit'];
+    threshold: {
+        operator: SLI['threshold']['operator'];
+        value: number;
+    };
+    category?: SLI['category'];
+    tags?: string[];
+}): SLI;