qa360 2.2.1 → 2.2.13

package/cli/dist/core/fixtures/resolver.js

@@ -0,0 +1,181 @@
+/**
+ * QA360 Data Fixtures Resolver
+ *
+ * Resolves fixture references in configuration objects.
+ *
+ * Syntax:
+ * - $fixtures.fixtureName.key.subkey
+ * - Nested in objects: { url: "/login", email: "$fixtures.users.buyer.email" }
+ * - In arrays: ["$fixtures.users.buyer.email", "$fixtures.users.admin.email"]
+ */
+import { FixtureError, } from './types.js';
+import { FixtureLoader } from './loader.js';
+/**
+ * Fixture reference pattern: $fixtures.path.to.value
+ */
+const FIXTURE_REF_PATTERN = /^\$fixtures\.([\w.]+)$/;
+/**
+ * Variable substitution pattern for strings containing fixtures:
+ * Matches the longest possible fixture path (greedy)
+ * "https://example.com?user=$fixtures.users.buyer.id"
+ */
+const INTERPOLATION_PATTERN = /\$fixtures\.([\w.]+)/g;
+export class FixtureResolver {
+    loader;
+    baseDir;
+    unresolved = [];
+    constructor(loader, baseDir) {
+        this.loader = loader;
+        this.baseDir = baseDir;
+    }
+    /**
+     * Resolve fixture references in a configuration object
+     *
+     * @param config - The configuration object to resolve
+     * @param options - Resolver options
+     * @returns The resolved configuration
+     */
+    resolve(config, options) {
+        this.unresolved = [];
+        const hasFixtures = this.hasFixtureReferences(config);
+        if (!hasFixtures) {
+            return { value: config, hasFixtures: false };
+        }
+        const resolved = this.resolveValue(config, options);
+        return {
+            value: resolved,
+            hasFixtures: true,
+            unresolved: this.unresolved.length > 0 ? this.unresolved : undefined,
+        };
+    }
+    /**
+     * Check if a value contains any fixture references
+     *
+     * @param value - The value to check
+     * @returns True if fixture references are found
+     */
+    hasFixtureReferences(value) {
+        if (typeof value === 'string') {
+            return FIXTURE_REF_PATTERN.test(value) || INTERPOLATION_PATTERN.test(value);
+        }
+        if (Array.isArray(value)) {
+            return value.some(v => this.hasFixtureReferences(v));
+        }
+        if (value && typeof value === 'object') {
+            return Object.values(value).some(v => this.hasFixtureReferences(v));
+        }
+        return false;
+    }
+    /**
+     * Resolve fixture references in a value
+     *
+     * @param value - The value to resolve
+     * @param options - Resolver options
+     * @returns The resolved value
+     */
+    resolveValue(value, options) {
+        // String with direct fixture reference
+        if (typeof value === 'string') {
+            const directMatch = value.match(FIXTURE_REF_PATTERN);
+            if (directMatch) {
+                return this.resolveFixturePath(directMatch[1], options);
+            }
+            // String with interpolation (e.g., "user=$fixtures.users.buyer.id")
+            // Check if the string contains $fixtures pattern
+            if (value.includes('$fixtures')) {
+                return value.replace(INTERPOLATION_PATTERN, (_, path) => {
+                    const resolved = this.resolveFixturePath(path, options);
+                    return String(resolved);
+                });
+            }
+            return value;
+        }
+        // Array - resolve each element
+        if (Array.isArray(value)) {
+            return value.map(item => this.resolveValue(item, options));
+        }
+        // Object - resolve each value
+        if (value && typeof value === 'object') {
+            const resolved = {};
+            for (const [key, val] of Object.entries(value)) {
+                resolved[key] = this.resolveValue(val, options);
+            }
+            return resolved;
+        }
+        // Primitive value - return as is
+        return value;
+    }
+    /**
+     * Resolve a fixture path (e.g., "testUsers.buyer.email")
+     *
+     * @param path - The fixture path
+     * @param options - Resolver options
+     * @returns The resolved fixture value
+     */
+    resolveFixturePath(path, options) {
+        try {
+            return this.loader.get(path);
+        }
+        catch (error) {
+            if (options.keepUnresolved) {
+                this.unresolved.push(path);
+                return '$fixtures.' + path;
+            }
+            throw new FixtureError('Failed to resolve fixture reference: $fixtures.' + path, 'FIXTURE_RESOLUTION_ERROR');
+        }
+    }
+    /**
+     * Parse a fixture reference string
+     *
+     * @param ref - The reference string (e.g., "$fixtures.testUsers.buyer")
+     * @returns The parsed reference
+     */
+    parseReference(ref) {
+        const match = ref.match(FIXTURE_REF_PATTERN);
+        if (!match) {
+            return null;
+        }
+        const path = match[1].split('.');
+        const fixtureFile = path[0];
+        const valuePath = path.slice(1);
+        return {
+            fixtureFile,
+            valuePath,
+        };
+    }
+    /**
+     * Create a fixture reference string
+     *
+     * @param fixtureFile - The fixture file name
+     * @param valuePath - The path within the fixture
+     * @returns The fixture reference string
+     */
+    createReference(fixtureFile, ...valuePath) {
+        if (valuePath.length === 0) {
+            return '$fixtures.' + fixtureFile;
+        }
+        return '$fixtures.' + fixtureFile + '.' + valuePath.join('.');
+    }
+    /**
+     * Get the list of unresolved references from the last resolve() call
+     *
+     * @returns Array of unresolved paths
+     */
+    getUnresolved() {
+        return [...this.unresolved];
+    }
+}
+/**
+ * Resolve fixtures in a configuration object (convenience function)
+ *
+ * @param config - The configuration object
+ * @param fixturePaths - Array of fixture file paths
+ * @param baseDir - Base directory for resolving relative paths
+ * @returns The resolved configuration
+ */
+export async function resolveFixtures(config, fixturePaths, baseDir) {
+    const loader = new FixtureLoader(baseDir);
+    await loader.load(fixturePaths);
+    const resolver = new FixtureResolver(loader, baseDir);
+    return resolver.resolve(config, { baseDir, keepUnresolved: false });
+}

package/cli/dist/core/fixtures/types.d.ts

@@ -0,0 +1,75 @@
+/**
+ * QA360 Data Fixtures System
+ *
+ * Provides separation of test data from test logic (Playwright/NFLS best practice).
+ *
+ * Syntax:
+ * ```yaml
+ * fixtures:
+ *   - ./fixtures/users.yml
+ *
+ * gates:
+ *   login-test:
+ *     adapter: playwright-ui
+ *     config:
+ *       data: $fixtures.testUsers.buyer
+ * ```
+ */
+/**
+ * Fixture data structure (any JSON-serializable value)
+ */
+export type FixtureValue = string | number | boolean | null | undefined | FixtureValue[] | {
+    [key: string]: FixtureValue;
+};
+/**
+ * Fixture file containing named fixture sets
+ */
+export interface FixtureFile {
+    [name: string]: FixtureValue;
+}
+/**
+ * Loaded fixtures registry
+ */
+export type FixtureRegistry = Record<string, FixtureFile>;
+/**
+ * Variable reference in the form: $fixtures.path.to.value
+ */
+export interface FixtureReference {
+    type: 'fixture';
+    path: string[];
+}
+/**
+ * Parsed fixture reference
+ */
+export interface ParsedReference {
+    fixtureFile: string;
+    valuePath: string[];
+}
+/**
+ * Fixture resolver options
+ */
+export interface FixtureResolverOptions {
+    /** Base directory for resolving relative fixture paths */
+    baseDir: string;
+    /** Whether to keep unresolved references (default: false) */
+    keepUnresolved?: boolean;
+}
+/**
+ * Fixture resolver result
+ */
+export interface FixtureResolverResult {
+    /** The resolved value */
+    value: unknown;
+    /** Whether any fixture references were found */
+    hasFixtures: boolean;
+    /** Any unresolved references (if keepUnresolved=true) */
+    unresolved?: string[];
+}
+/**
+ * Fixture loader error
+ */
+export declare class FixtureError extends Error {
+    code: string;
+    filePath?: string | undefined;
+    constructor(message: string, code: string, filePath?: string | undefined);
+}

package/cli/dist/core/fixtures/types.js

@@ -0,0 +1,30 @@
+/**
+ * QA360 Data Fixtures System
+ *
+ * Provides separation of test data from test logic (Playwright/NFLS best practice).
+ *
+ * Syntax:
+ * ```yaml
+ * fixtures:
+ *   - ./fixtures/users.yml
+ *
+ * gates:
+ *   login-test:
+ *     adapter: playwright-ui
+ *     config:
+ *       data: $fixtures.testUsers.buyer
+ * ```
+ */
+/**
+ * Fixture loader error
+ */
+export class FixtureError extends Error {
+    code;
+    filePath;
+    constructor(message, code, filePath) {
+        super(message);
+        this.code = code;
+        this.filePath = filePath;
+        this.name = 'FixtureError';
+    }
+}

package/cli/dist/core/flakiness/index.d.ts

@@ -0,0 +1,228 @@
+/**
+ * QA360 Flakiness Detection Engine
+ *
+ * Detects and scores test flakiness using consecutive runs and pattern analysis.
+ * This is the core differentiator of QA360 - measuring test reliability.
+ *
+ * Scoring Categories:
+ * - Legendary (100): Never flaky - 100% reliable
+ * - Solid (90-99): Rarely flaky
+ * - Good (75-89): Occasionally flaky
+ * - Shaky (50-74): Often flaky - attention needed
+ * - Unstable (0-49): Very flaky - quarantine recommended
+ *
+ * @module flakiness
+ */
+/**
+ * Flakiness score category
+ */
+export declare enum FlakinessCategory {
+    LEGENDARY = "legendary",// 100
+    SOLID = "solid",// 90-99
+    GOOD = "good",// 75-89
+    SHAKY = "shaky",// 50-74
+    UNSTABLE = "unstable"
+}
+/**
+ * Flakiness category metadata
+ */
+export declare const FLAKINESS_CATEGORIES: Record<FlakinessCategory, {
+    min: number;
+    max: number;
+    label: string;
+    emoji: string;
+    color: string;
+    description: string;
+    action: string;
+}>;
+/**
+ * Test result from a single run
+ */
+export interface TestResult {
+    /** Test identifier (unique per test) */
+    testId: string;
+    /** Test name/title */
+    testName: string;
+    /** File path */
+    filePath: string;
+    /** Gate name */
+    gate: string;
+    /** Whether the test passed */
+    success: boolean;
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Error type if failed */
+    errorType?: string;
+    /** Error message if failed */
+    errorMessage?: string;
+    /** Timestamp of run */
+    timestamp: number;
+    /** Environment (local, ci, staging) */
+    environment: string;
+    /** Git branch */
+    branch?: string;
+    /** Commit hash */
+    commitHash?: string;
+    /** CI run ID */
+    ciRunId?: string;
+    /** Tags (team, repo, etc.) */
+    tags?: Record<string, string>;
+}
+/**
+ * Flakiness detection result for a single test
+ */
+export interface FlakinessResult {
+    /** Test identifier */
+    testId: string;
+    /** Test name */
+    testName: string;
+    /** File path */
+    filePath: string;
+    /** Gate name */
+    gate: string;
+    /** Flakiness score (0-100) */
+    score: number;
+    /** Flakiness category */
+    category: FlakinessCategory;
+    /** Total number of runs analyzed */
+    totalRuns: number;
+    /** Number of successful runs */
+    successfulRuns: number;
+    /** Average duration in ms */
+    avgDurationMs: number;
+    /** Detected pattern type (if any) */
+    patternType?: string;
+    /** Suggested fix */
+    suggestedFix?: string;
+    /** Confidence in pattern detection (0-1) */
+    confidence?: number;
+    /** First seen timestamp */
+    firstSeen?: number;
+    /** Last seen timestamp */
+    lastSeen?: number;
+    /** Current streak (consecutive passes or failures) */
+    currentStreak?: number;
+    /** Streak type */
+    streakType?: 'pass' | 'fail';
+}
+/**
+ * Flakiness detection options
+ */
+export interface FlakinessDetectionOptions {
+    /** Minimum runs before calculating score */
+    minRuns?: number;
+    /** Number of consecutive runs for detection */
+    consecutiveRuns?: number;
+    /** Time window in days (only consider runs within this window) */
+    timeWindowDays?: number;
+    /** Enable pattern detection */
+    enablePatternDetection?: boolean;
+}
+/**
+ * Default flakiness detection options
+ */
+export declare const DEFAULT_FLAKINESS_OPTIONS: Required<FlakinessDetectionOptions>;
+/**
+ * Flakiness pattern types
+ */
+export declare enum FlakinessPattern {
+    TIMING = "timing",
+    RACE_CONDITION = "race_condition",
+    EXTERNAL_DEPENDENCY = "external_dependency",
+    ENVIRONMENT_SPECIFIC = "environment_specific",
+    SELECTOR_ISSUE = "selector_issue",
+    UNKNOWN = "unknown"
+}
+/**
+ * Pattern detection result
+ */
+export interface PatternDetection {
+    /** Pattern type */
+    patternType: FlakinessPattern;
+    /** Pattern description */
+    description: string;
+    /** Suggested fix */
+    suggestedFix: string;
+    /** Confidence (0-1) */
+    confidence: number;
+    /** Whether auto-fix is possible */
+    autoFixPossible: boolean;
+}
+/**
+ * Calculate flakiness score from test results
+ * @param results Array of test results
+ * @returns Flakiness score (0-100)
+ */
+export declare function calculateFlakinessScore(results: TestResult[]): number;
+/**
+ * Get flakiness category from score
+ * @param score Flakiness score (0-100)
+ * @returns Flakiness category
+ */
+export declare function getFlakinessCategory(score: number): FlakinessCategory;
+/**
+ * Generate a unique test ID
+ * @param testName Test name
+ * @param filePath File path
+ * @returns Unique test ID
+ */
+export declare function generateTestId(testName: string, filePath: string): string;
+/**
+ * Analyze test results for flakiness patterns
+ * @param results Array of test results for the same test
+ * @returns Pattern detection result or undefined
+ */
+export declare function detectFlakinessPattern(results: TestResult[]): PatternDetection | undefined;
+/**
+ * Calculate consecutive streak (passes or failures)
+ * @param results Array of test results sorted by timestamp
+ * @returns Current streak info
+ */
+export declare function calculateStreak(results: TestResult[]): {
+    currentStreak: number;
+    streakType: 'pass' | 'fail';
+};
+/**
+ * Format flakiness score for display
+ * @param score Flakiness score (0-100)
+ * @returns Formatted string with emoji
+ */
+export declare function formatFlakinessScore(score: number): string;
+/**
+ * Flakiness Detection Engine
+ *
+ * Main class for detecting and scoring test flakiness
+ */
+export declare class FlakinessDetector {
+    private options;
+    constructor(options?: FlakinessDetectionOptions);
+    /**
+     * Analyze a single test's flakiness from its run history
+     * @param testId Test identifier
+     * @param results Array of test results (must be from the same test)
+     * @returns Flakiness result
+     */
+    analyzeTest(testId: string, results: TestResult[]): FlakinessResult;
+    /**
+     * Analyze multiple tests and return flakiness results
+     * @param testResults Map of testId to array of results
+     * @returns Array of flakiness results
+     */
+    analyzeAll(testResults: Map<string, TestResult[]>): FlakinessResult[];
+    /**
+     * Check if a test should be quarantined based on flakiness
+     * @param result Flakiness result
+     * @returns Whether to quarantine
+     */
+    shouldQuarantine(result: FlakinessResult): boolean;
+    /**
+     * Get quarantine recommendation message
+     * @param result Flakiness result
+     * @returns Recommendation message
+     */
+    getQuarantineRecommendation(result: FlakinessResult): string;
+    /**
+     * Calculate average duration
+     */
+    private averageDuration;
+}