qa360 2.0.12 → 2.1.0

package/dist/core/reporting/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * QA360 Reporting Module
+ *
+ * Generates test reports in various formats (HTML, JSON, JUnit)
+ */
+export { HTMLReporter, generateHTMLReport, type ReportData, type TestReport, type StepReport, type ReportScreenshotArtifact as ScreenshotArtifact, type ReportVideoArtifact as VideoArtifact, type ReportTraceArtifact as TraceArtifact, } from './html-reporter.js';

package/dist/core/reporting/index.js

@@ -0,0 +1,6 @@
+/**
+ * QA360 Reporting Module
+ *
+ * Generates test reports in various formats (HTML, JSON, JUnit)
+ */
+export { HTMLReporter, generateHTMLReport, } from './html-reporter.js';

package/dist/core/runner/phase3-runner.js

@@ -508,7 +508,11 @@ export class Phase3Runner {
             },
             budgets: gateConfigData.budgets,
             timeout: gateConfigData.timeout,
-            auth: credentials
+            auth: credentials,
+            // Playwright++ features
+            artifacts: gateConfigData.artifacts,
+            htmlReport: gateConfigData.htmlReport,
+            bail: gateConfigData.bail
         };
         const result = await adapter.runSmokeTests(config);
         return {

package/dist/core/types/pack-v1.d.ts

@@ -13,6 +13,96 @@ export interface ApiTarget {
 export interface WebTarget {
     baseUrl: string;
     pages?: string[];
+    /** Browser mode: true for headed (visible), false for headless (default) */
+    headless?: boolean;
+    /** Slow motion delay in ms between actions (for debugging) */
+    slowMo?: number;
+    /** Viewport size */
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    /** Screenshot mode: 'always', 'never', 'only-on-fail' (default) */
+    screenshot?: 'always' | 'never' | 'only-on-fail';
+    /** Video recording mode: 'always', 'never' (default), 'retain-on-fail' */
+    video?: 'always' | 'never' | 'retain-on-fail';
+    /** Trace mode: 'always', 'never' (default), 'retain-on-fail' */
+    trace?: 'always' | 'never' | 'retain-on-fail';
+    /** Device emulation */
+    device?: 'desktop' | 'mobile' | 'tablet';
+    /** Browser to use: 'chromium' (default), 'firefox', 'webkit' */
+    browser?: 'chromium' | 'firefox' | 'webkit';
+    /** UI test definitions */
+    uiTests?: UiTestDefinition[];
+}
+/** UI Test Step Action */
+export type UiAction = 'navigate' | 'click' | 'dblClick' | 'rightClick' | 'hover' | 'focus' | 'fill' | 'type' | 'clear' | 'select' | 'check' | 'uncheck' | 'upload' | 'press' | 'waitFor' | 'waitForSelector' | 'waitForNavigation' | 'waitForTimeout' | 'scroll' | 'dragAndDrop' | 'tap';
+/** UI Test Step */
+export interface UiTestStep {
+    /** Step order */
+    order?: number;
+    /** Action to perform */
+    action: UiAction;
+    /** CSS selector for element */
+    selector?: string;
+    /** Value to input */
+    value?: string;
+    /** Options for the action */
+    options?: Record<string, any>;
+    /** Expected outcome after this step */
+    expected?: {
+        /** Expected URL */
+        url?: string;
+        /** URL contains string */
+        urlContains?: string;
+        /** Expected visible element */
+        visible?: string;
+        /** Expected hidden element */
+        hidden?: string;
+        /** Expected text content */
+        text?: string;
+        /** Expected element text content */
+        elementText?: {
+            selector: string;
+            text: string;
+        };
+    };
+    /** Wait time in ms after action */
+    wait?: number;
+    /** Description of what this step does */
+    description?: string;
+}
+/** UI Test Definition */
+export interface UiTestDefinition {
+    /** Test name */
+    name: string;
+    /** Starting path (relative to baseUrl) */
+    path?: string;
+    /** Full URL (overrides baseUrl + path) */
+    url?: string;
+    /** Test steps */
+    steps: UiTestStep[];
+    /** Description */
+    description?: string;
+    /** Whether this test is enabled */
+    enabled?: boolean;
+    /** Test timeout in ms */
+    timeout?: number;
+    /** Tags for organizing tests */
+    tags?: string[];
+}
+/** Assertion for UI tests */
+export interface UiAssertion {
+    /** Assertion type */
+    type: 'visible' | 'hidden' | 'text' | 'contains' | 'value' | 'attribute' | 'class' | 'count' | 'url' | 'title' | 'enabled' | 'disabled' | 'checked' | 'focused';
+    /** CSS selector */
+    selector?: string;
+    /** Expected value */
+    expected?: any;
+    /** Whether to negate */
+    not?: boolean;
+    /** Timeout in ms */
+    timeout?: number;
 }
 export interface PackTargets {
     api?: ApiTarget;

package/dist/core/vault/cas.d.ts

@@ -58,7 +58,11 @@ export declare class ContentAddressableStorage {
     /**
      * Calculate SHA256 hash of content
      */
-    private calculateHash;
+    calculateHash(content: Buffer): string;
+    /**
+     * Calculate SHA256 hash of content (static utility)
+     */
+    static hashContent(content: Buffer): string;
     /**
      * Get CAS file path for a given hash (with sharding)
      */

package/dist/core/vault/cas.js

@@ -165,6 +165,12 @@ export class ContentAddressableStorage {
     calculateHash(content) {
         return createHash('sha256').update(content).digest('hex');
     }
+    /**
+     * Calculate SHA256 hash of content (static utility)
+     */
+    static hashContent(content) {
+        return createHash('sha256').update(content).digest('hex');
+    }
     /**
      * Get CAS file path for a given hash (with sharding)
      */

package/dist/core/visual/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * QA360 Visual Regression Module
+ *
+ * Visual comparison testing for UI changes
+ */
+export { VisualRegressionTester, createVisualRegressionTester, runVisualRegressionTests, type VisualRegressionConfig, type VisualRegressionResult, type ScreenshotData, } from './visual-regression.js';

package/dist/core/visual/index.js

@@ -0,0 +1,6 @@
+/**
+ * QA360 Visual Regression Module
+ *
+ * Visual comparison testing for UI changes
+ */
+export { VisualRegressionTester, createVisualRegressionTester, runVisualRegressionTests, } from './visual-regression.js';

package/dist/core/visual/visual-regression.d.ts

@@ -0,0 +1,113 @@
+/**
+ * QA360 Visual Regression Testing
+ *
+ * Compares screenshots against baselines to detect visual changes.
+ * Uses pixel diffing with configurable thresholds.
+ */
+export interface VisualRegressionConfig {
+    /** Directory to store baseline images */
+    baselineDir?: string;
+    /** Directory to store actual images */
+    actualDir?: string;
+    /** Directory to store diff images */
+    diffDir?: string;
+    /** Maximum allowed pixel difference (0-1) */
+    maxDiffThreshold?: number;
+    /** Maximum allowed different pixels (0-1) */
+    maxDifferentPixels?: number;
+    /** Whether to update baselines */
+    updateBaselines?: boolean;
+    /** Whether to ignore anti-aliasing differences */
+    ignoreAntiAliasing?: boolean;
+    /** Color to highlight differences */
+    diffColor?: {
+        r: number;
+        g: number;
+        b: number;
+    };
+}
+export interface VisualRegressionResult {
+    name: string;
+    status: 'pass' | 'fail' | 'updated';
+    diffPixels: number;
+    diffPercentage: number;
+    diffImagePath?: string;
+    baselinePath: string;
+    actualPath: string;
+    error?: string;
+}
+export interface ScreenshotData {
+    width: number;
+    height: number;
+    data: Buffer;
+}
+/**
+ * Visual Regression Tester
+ *
+ * Captures screenshots and compares them against baseline images.
+ */
+export declare class VisualRegressionTester {
+    private baselineDir;
+    private actualDir;
+    private diffDir;
+    private maxDiffThreshold;
+    private maxDifferentPixels;
+    private updateBaselines;
+    private ignoreAntiAliasing;
+    private diffColor;
+    constructor(config?: VisualRegressionConfig);
+    private ensureDirectories;
+    /**
+     * Compare a screenshot against baseline
+     */
+    compare(name: string, screenshot: Buffer, width: number, height: number): Promise<VisualRegressionResult>;
+    /**
+     * Compare two image buffers
+     */
+    private compareBuffers;
+    /**
+     * Generate a diff image highlighting differences
+     */
+    private generateDiffImage;
+    /**
+     * Get baseline file path for a test
+     */
+    private getBaselinePath;
+    /**
+     * Get actual file path for a test
+     */
+    private getActualPath;
+    /**
+     * Get diff file path for a test
+     */
+    private getDiffPath;
+    /**
+     * Get hash of a screenshot for deduplication
+     */
+    getScreenshotHash(screenshot: Buffer): string;
+    /**
+     * Clean up old actual screenshots
+     */
+    cleanup(maxAge?: number): void;
+}
+/**
+ * Create a visual regression tester
+ */
+export declare function createVisualRegressionTester(config?: VisualRegressionConfig): VisualRegressionTester;
+/**
+ * Run visual regression tests
+ */
+export declare function runVisualRegressionTests(tests: Array<{
+    name: string;
+    screenshot: Buffer;
+    width: number;
+    height: number;
+}>, config?: VisualRegressionConfig): Promise<{
+    results: VisualRegressionResult[];
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        updated: number;
+    };
+}>;

package/dist/core/visual/visual-regression.js

@@ -0,0 +1,236 @@
+/**
+ * QA360 Visual Regression Testing
+ *
+ * Compares screenshots against baselines to detect visual changes.
+ * Uses pixel diffing with configurable thresholds.
+ */
+import { mkdirSync, existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { createHash } from 'crypto';
+/**
+ * Visual Regression Tester
+ *
+ * Captures screenshots and compares them against baseline images.
+ */
+export class VisualRegressionTester {
+    baselineDir;
+    actualDir;
+    diffDir;
+    maxDiffThreshold;
+    maxDifferentPixels;
+    updateBaselines;
+    ignoreAntiAliasing;
+    diffColor;
+    constructor(config = {}) {
+        this.baselineDir = config.baselineDir || '.qa360/visual/baselines';
+        this.actualDir = config.actualDir || '.qa360/visual/actual';
+        this.diffDir = config.diffDir || '.qa360/visual/diffs';
+        this.maxDiffThreshold = config.maxDiffThreshold ?? 0.01; // 1% max diff per pixel
+        this.maxDifferentPixels = config.maxDifferentPixels ?? 0.001; // 0.1% of pixels can differ
+        this.updateBaselines = config.updateBaselines ?? false;
+        this.ignoreAntiAliasing = config.ignoreAntiAliasing ?? true;
+        this.diffColor = config.diffColor || { r: 255, g: 0, b: 0 }; // Red
+        this.ensureDirectories();
+    }
+    ensureDirectories() {
+        for (const dir of [this.baselineDir, this.actualDir, this.diffDir]) {
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+        }
+    }
+    /**
+     * Compare a screenshot against baseline
+     */
+    async compare(name, screenshot, width, height) {
+        const baselinePath = this.getBaselinePath(name);
+        const actualPath = this.getActualPath(name);
+        // Save actual screenshot
+        writeFileSync(actualPath, screenshot);
+        // Check if baseline exists
+        if (!existsSync(baselinePath)) {
+            if (this.updateBaselines) {
+                writeFileSync(baselinePath, screenshot);
+                return {
+                    name,
+                    status: 'updated',
+                    diffPixels: 0,
+                    diffPercentage: 0,
+                    baselinePath,
+                    actualPath,
+                };
+            }
+            return {
+                name,
+                status: 'fail',
+                diffPixels: -1,
+                diffPercentage: 100,
+                baselinePath,
+                actualPath,
+                error: 'No baseline found. Run with --update-baselines to create one.',
+            };
+        }
+        // Load baseline
+        const baseline = readFileSync(baselinePath);
+        // Compare images
+        const diff = this.compareBuffers(baseline, screenshot, width, height);
+        // Determine if test passes
+        const pixelDiffRatio = diff.diffPixels / (width * height);
+        const passes = pixelDiffRatio <= this.maxDifferentPixels &&
+            diff.maxDiffValue <= this.maxDiffThreshold;
+        // Generate diff image if failed
+        let diffImagePath;
+        if (!passes || this.updateBaselines) {
+            diffImagePath = this.getDiffPath(name);
+            this.generateDiffImage(baseline, screenshot, width, height, diff.diffBuffer, diffImagePath);
+        }
+        // Update baseline if requested
+        if (this.updateBaselines && !passes) {
+            writeFileSync(baselinePath, screenshot);
+            return {
+                name,
+                status: 'updated',
+                diffPixels: diff.diffPixels,
+                diffPercentage: (diff.diffPixels / (width * height)) * 100,
+                diffImagePath,
+                baselinePath,
+                actualPath,
+            };
+        }
+        return {
+            name,
+            status: passes ? 'pass' : 'fail',
+            diffPixels: diff.diffPixels,
+            diffPercentage: (diff.diffPixels / (width * height)) * 100,
+            diffImagePath,
+            baselinePath,
+            actualPath,
+        };
+    }
+    /**
+     * Compare two image buffers
+     */
+    compareBuffers(baseline, actual, width, height) {
+        // Assume PNG format (simplified - would use PNG decoder in production)
+        // For now, just compare raw buffer sizes as a simple check
+        if (baseline.length !== actual.length) {
+            return {
+                diffPixels: width * height,
+                maxDiffValue: 1,
+                diffBuffer: Buffer.alloc(width * height * 4),
+            };
+        }
+        const baselineData = new Uint8ClampedArray(baseline);
+        const actualData = new Uint8ClampedArray(actual);
+        const diffBuffer = new Uint8ClampedArray(baseline.length);
+        let diffPixels = 0;
+        let maxDiffValue = 0;
+        // Compare pixel by pixel (assuming RGBA)
+        for (let i = 0; i < baselineData.length; i += 4) {
+            const r1 = baselineData[i];
+            const g1 = baselineData[i + 1];
+            const b1 = baselineData[i + 2];
+            const a1 = baselineData[i + 3];
+            const r2 = actualData[i];
+            const g2 = actualData[i + 1];
+            const b2 = actualData[i + 2];
+            const a2 = actualData[i + 3];
+            // Calculate color difference
+            const diffR = Math.abs(r1 - r2);
+            const diffG = Math.abs(g1 - g2);
+            const diffB = Math.abs(b1 - b2);
+            const diffA = Math.abs(a1 - a2);
+            // Overall difference (normalized 0-1)
+            const diffValue = Math.max(diffR, diffG, diffB, diffA) / 255;
+            maxDiffValue = Math.max(maxDiffValue, diffValue);
+            // Check if pixel differs significantly
+            const isDifferent = diffValue > (this.ignoreAntiAliasing ? 0.05 : 0);
+            if (isDifferent) {
+                diffPixels++;
+                // Store diff color in diff buffer
+                diffBuffer[i] = this.diffColor.r;
+                diffBuffer[i + 1] = this.diffColor.g;
+                diffBuffer[i + 2] = this.diffColor.b;
+                diffBuffer[i + 3] = 255;
+            }
+            else {
+                // Store original pixel
+                diffBuffer[i] = r2;
+                diffBuffer[i + 1] = g2;
+                diffBuffer[i + 2] = b2;
+                diffBuffer[i + 3] = a2;
+            }
+        }
+        return {
+            diffPixels,
+            maxDiffValue,
+            diffBuffer: Buffer.from(diffBuffer),
+        };
+    }
+    /**
+     * Generate a diff image highlighting differences
+     */
+    generateDiffImage(baseline, actual, width, height, diffBuffer, outputPath) {
+        // In production, this would create a proper PNG
+        // For now, just save the diff buffer
+        writeFileSync(outputPath, diffBuffer);
+    }
+    /**
+     * Get baseline file path for a test
+     */
+    getBaselinePath(name) {
+        const hash = createHash('md5').update(name).digest('hex').substring(0, 8);
+        return join(this.baselineDir, `${hash}.png`);
+    }
+    /**
+     * Get actual file path for a test
+     */
+    getActualPath(name) {
+        const hash = createHash('md5').update(name).digest('hex').substring(0, 8);
+        return join(this.actualDir, `${hash}.png`);
+    }
+    /**
+     * Get diff file path for a test
+     */
+    getDiffPath(name) {
+        const hash = createHash('md5').update(name).digest('hex').substring(0, 8);
+        return join(this.diffDir, `${hash}.png`);
+    }
+    /**
+     * Get hash of a screenshot for deduplication
+     */
+    getScreenshotHash(screenshot) {
+        return createHash('sha256').update(screenshot).digest('hex');
+    }
+    /**
+     * Clean up old actual screenshots
+     */
+    cleanup(maxAge = 24 * 60 * 60 * 1000) {
+        const now = Date.now();
+        // Implementation would clean up old files
+    }
+}
+/**
+ * Create a visual regression tester
+ */
+export function createVisualRegressionTester(config) {
+    return new VisualRegressionTester(config);
+}
+/**
+ * Run visual regression tests
+ */
+export async function runVisualRegressionTests(tests, config) {
+    const tester = new VisualRegressionTester(config);
+    const results = [];
+    for (const test of tests) {
+        const result = await tester.compare(test.name, test.screenshot, test.width, test.height);
+        results.push(result);
+    }
+    const summary = {
+        total: results.length,
+        passed: results.filter((r) => r.status === 'pass').length,
+        failed: results.filter((r) => r.status === 'fail').length,
+        updated: results.filter((r) => r.status === 'updated').length,
+    };
+    return { results, summary };
+}

package/dist/index.js

@@ -32,9 +32,10 @@ import { coverageCommand } from './commands/coverage.js';
 import { sloCommand } from './commands/slo.js';
 import { regressionCommand } from './commands/regression.js';
 import { createRetryCommands } from './commands/retry.js';
+import { createCrawlCommand } from './commands/crawl.js';
 // import { createMonitorCommands } from './commands/monitor.js'; // TODO: Re-enable monitor imports
 // import { createOllamaCommands } from './commands/ollama.js'; // TODO: Re-enable when Ollama exports from core are fixed
-// import { createGenerateCommands } from './commands/generate.js'; // TODO: fix generation imports
+import { createGenerateCommands } from './commands/generate.js';
 // import { createRepairCommand } from './commands/repair.js'; // TODO: fix repair imports
 const program = new Command();
 program
@@ -99,6 +100,7 @@ program
     .option('--retries <number>', 'Number of retries for failed tests', '2')
     .option('--timeout <ms>', 'Global timeout for tests in milliseconds', '30000')
     .option('--docker', 'Use Docker fallback for missing tools')
+    .option('--headed', 'Run UI tests in headed mode (visible browser)')
     .action(async (pack, options) => {
     await runCommand(pack, options);
 });
@@ -212,7 +214,7 @@ program.addCommand(createFlakinessCommands());
 program.addCommand(createAICommands());
 // program.addCommand(createOllamaCommands()); // TODO: Re-enable when Ollama exports from core are fixed
 // Generate AI commands (Phase 4)
-// program.addCommand(createGenerateCommands()); // TODO: Re-enable after fixing imports
+program.addCommand(createGenerateCommands());
 // Repair Commands (Phase 7 - Auto-Repair)
 // program.addCommand(createRepairCommand()); // TODO: Re-enable after fixing imports
 // Monitor Commands (Phase 8 - TUI & Dashboard)
@@ -226,6 +228,8 @@ program.addCommand(sloCommand);
 program.addCommand(regressionCommand);
 // Retry Commands (Vision 2.0 - Phase 2 - F8 Smart Retry)
 program.addCommand(createRetryCommands());
+// Crawl Command (UI Testing 100% - Auto-generate packs from websites)
+program.addCommand(createCrawlCommand());
 // Show banner
 console.log(chalk.bold.blue('QA360 Core v' + version));
 console.log(chalk.gray('Transform software testing into verifiable, signed, and traceable proofs\n'));

package/examples/README.md

@@ -45,6 +45,44 @@ qa360 run examples/ui-basic.yml
 
 ---
 
+### 2b. **ui-advanced.yml** - UI Tests with Playwright++
+Advanced UI testing with artifacts, video, screenshots, and HTML reports.
+
+**Gates**: `ui`
+
+**Features**:
+- Automatic screenshots on failure
+- Video recording
+- Trace capture for debugging
+- Interactive HTML report generation
+- Configurable bail on failures
+
+**Use case**: Full-featured UI testing with rich artifacts
+
+```bash
+qa360 run examples/ui-advanced.yml
+```
+
+---
+
+### 2c. **crawler.yml** - Web Crawler
+Auto-generate tests by crawling a web application.
+
+**Gates**: `ui`
+
+**Features**:
+- Automatic discovery of pages and forms
+- Generate test packs from existing sites
+- Smart selector generation
+
+**Use case**: Quick start with existing applications
+
+```bash
+qa360 run examples/crawler.yml
+```
+
+---
+
 ### 3. **fullstack.yml** - Full Stack Tests
 API + UI + Performance testing.
 

package/examples/accessibility.yml

@@ -1,25 +1,48 @@
 # QA360 Example: Accessibility Tests
 # WCAG compliance and accessibility testing
 
-version: 1
+version: 2
 name: accessibility-tests
+description: WCAG compliance and accessibility testing
 
 gates:
-  - ui
-  - a11y
+  ui-smoke:
+    adapter: playwright-ui
+    enabled: true
+    config:
+      baseUrl: "https://example.com"
+      pages:
+        - url: "/"
+          expectedElements: ["body", "main"]
+        - url: "/about"
+          expectedElements: ["body"]
+        - url: "/contact"
+          expectedElements: ["body", "form"]
 
-targets:
-  web:
-    baseUrl: "https://example.com"
-    pages:
-      - "https://example.com"
-      - "https://example.com/about"
-      - "https://example.com/contact"
-
-# Accessibility budget
-budgets:
-  a11y_min: 90  # Minimum accessibility score (0-100)
+  a11y:
+    adapter: playwright-ui
+    enabled: true
+    config:
+      baseUrl: "https://example.com"
+      pages:
+        - url: "/"
+          a11yRules:
+            - wcag2a
+            - wcag2aa
+        - url: "/about"
+          a11yRules:
+            - wcag2a
+            - wcag2aa
+        - url: "/contact"
+          a11yRules:
+            - wcag2a
+            - wcag2aa
+    budgets:
+      violations: 5
+      a11y_score: 90
 
 execution:
-  timeout: 60000
-  max_retries: 1
+  default_timeout: 60000
+  default_retries: 1
+  on_failure: continue
+  parallel: true