qa360 2.0.13 → 2.1.1

package/dist/commands/scan.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Scan Command - Discover UI elements from a web page
+ */
+import { Command } from 'commander';
+export declare const scanCommand: Command;

package/dist/commands/scan.js

@@ -0,0 +1,155 @@
+/**
+ * Scan Command - Discover UI elements from a web page
+ */
+import { Command } from 'commander';
+import { chromium } from '@playwright/test';
+import { DOMScanner } from '../scanners/dom-scanner.js';
+import { JSONReporter } from '../generators/json-reporter.js';
+import { TestGenerator } from '../generators/test-generator.js';
+import { resolve } from 'path';
+import { mkdirSync } from 'fs';
+export const scanCommand = new Command('scan');
+scanCommand
+    .description('Scan a web page for UI elements and generate test configurations')
+    .argument('<url>', 'URL of the page to scan')
+    .option('-o, --output <file>', 'Output file path (default: ".qa360/discovery/elements.json")')
+    .option('-i, --include <types>', 'Element types to include: buttons,links,forms,inputs,images,headings,all (default: "all")')
+    .option('-e, --exclude <selectors>', 'CSS selectors to exclude (comma-separated)')
+    .option('-s, --screenshot', 'Capture screenshots of elements (not yet implemented)')
+    .option('-a, --auto-generate-test', 'Auto-generate QA360 test file')
+    .option('-t, --timeout <ms>', 'Navigation timeout in milliseconds', '30000')
+    .option('--headed', 'Run in headed mode (show browser)')
+    .action(async (url, options) => {
+    const startTime = Date.now();
+    // Validate URL
+    try {
+        new URL(url);
+    }
+    catch {
+        console.error(`❌ Invalid URL: ${url}`);
+        process.exit(1);
+    }
+    // Parse include types
+    const includeTypes = options.include || 'all';
+    const include = includeTypes
+        .split(',')
+        .map((t) => t.trim().toLowerCase());
+    // Validate element types
+    const validTypes = ['buttons', 'links', 'forms', 'inputs', 'images', 'headings', 'all'];
+    for (const type of include) {
+        if (!validTypes.includes(type)) {
+            console.error(`❌ Invalid element type: ${type}`);
+            console.error(`   Valid types: ${validTypes.join(', ')}`);
+            process.exit(1);
+        }
+    }
+    // Parse exclude selectors
+    const exclude = options.exclude
+        ? options.exclude.split(',').map((s) => s.trim())
+        : [];
+    const scanOptions = {
+        url,
+        output: options.output || '.qa360/discovery/elements.json',
+        include,
+        exclude,
+        screenshot: options.screenshot || false,
+        autoGenerateTest: options.autoGenerateTest || false,
+        timeout: parseInt(options.timeout, 10) || 30000,
+        headless: !options.headed
+    };
+    console.log(`🔍 Scanning page: ${url}`);
+    console.log('━'.repeat(50));
+    let browser = null;
+    let context = null;
+    let page = null;
+    try {
+        // Launch browser
+        browser = await chromium.launch({
+            headless: scanOptions.headless
+        });
+        context = await browser.newContext({
+            viewport: { width: 1280, height: 720 }
+        });
+        page = await context.newPage();
+        // Navigate to URL
+        await page.goto(url, {
+            timeout: scanOptions.timeout,
+            waitUntil: 'networkidle'
+        });
+        // Run scan
+        const scanner = new DOMScanner(page, url);
+        const elements = await scanner.scan(scanOptions);
+        // Generate summary
+        const summary = {
+            totalElements: elements.length,
+            buttons: elements.filter(e => e.type === 'button').length,
+            links: elements.filter(e => e.type === 'link').length,
+            forms: elements.filter(e => e.type === 'form').length,
+            inputs: elements.filter(e => e.type === 'input').length,
+            images: elements.filter(e => e.type === 'image').length,
+            headings: elements.filter(e => e.type === 'heading').length
+        };
+        // Print summary
+        console.log(`✅ Buttons found:      ${summary.buttons}`);
+        console.log(`✅ Links found:        ${summary.links}`);
+        console.log(`✅ Forms found:        ${summary.forms}`);
+        console.log(`✅ Inputs found:       ${summary.inputs}`);
+        console.log(`✅ Images found:       ${summary.images}`);
+        console.log(`✅ Headings found:     ${summary.headings}`);
+        console.log('━'.repeat(50));
+        console.log(`📦 Total elements:     ${summary.totalElements}`);
+        console.log();
+        // Create output directory
+        const outputPath = resolve(scanOptions.output);
+        const outputDir = outputPath.substring(0, outputPath.lastIndexOf('/'));
+        mkdirSync(outputDir, { recursive: true });
+        // Generate scan result
+        const result = {
+            scanDate: new Date().toISOString(),
+            url,
+            duration: Date.now() - startTime,
+            summary,
+            elements
+        };
+        // Generate JSON report
+        const reporter = new JSONReporter();
+        await reporter.generate(result, outputPath);
+        console.log(`💾 Saved to: ${outputPath}`);
+        // Auto-generate test if requested
+        if (options.autoGenerateTest) {
+            const testGenerator = new TestGenerator();
+            const testPath = outputPath.replace('.json', '.yml');
+            await testGenerator.generate(result, testPath);
+            console.log(`📄 Test generated: ${testPath}`);
+        }
+        // Screenshots (placeholder for future implementation)
+        if (options.screenshot) {
+            console.log(`📸 Screenshots: ${outputDir}/screenshots/ (not yet implemented)`);
+        }
+        // Cleanup
+        await page.close();
+        await context.close();
+        await browser.close();
+        console.log();
+        console.log(`✨ Scan completed in ${((Date.now() - startTime) / 1000).toFixed(1)}s`);
+        console.log();
+        console.log('💡 Next steps:');
+        console.log(`   • Review the discovered elements`);
+        if (options.autoGenerateTest) {
+            console.log(`   • Run the auto-generated test: qa360 run ${outputPath.replace('.json', '.yml')}`);
+        }
+        console.log(`   • Edit the test to remove unwanted elements`);
+    }
+    catch (error) {
+        // Cleanup on error
+        if (page)
+            await page.close().catch(() => { });
+        if (context)
+            await context.close().catch(() => { });
+        if (browser)
+            await browser.close().catch(() => { });
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`❌ Scan failed: ${errorMessage}`);
+        process.exit(1);
+    }
+});

package/dist/core/adapters/playwright-native-adapter.d.ts

@@ -0,0 +1,121 @@
+/**
+ * QA360 Playwright Native Adapter
+ *
+ * Zero-overhead adapter that uses Playwright's native API directly.
+ * This bypasses any wrapper logic and gives full access to Playwright's capabilities.
+ *
+ * Benefits:
+ * - Zero performance overhead
+ * - Full Playwright API access
+ * - Native video/trace/screenshot support
+ * - Direct access to browser context, page, locators
+ */
+import { Browser, BrowserContext, Page, Locator } from '@playwright/test';
+import type { WebTarget, PackBudgets, UiTestDefinition, UiTestStep } from '../types/pack-v1.js';
+export interface PlaywrightNativeConfig {
+    target: WebTarget;
+    budgets?: PackBudgets;
+    timeout?: number;
+    browser?: 'chromium' | 'firefox' | 'webkit';
+    headless?: boolean;
+    slowMo?: number;
+    devtools?: boolean;
+    device?: 'desktop' | 'tablet' | 'mobile' | 'custom';
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    userAgent?: string;
+    locale?: string;
+    timezone?: string;
+    screenshots?: 'always' | 'only-on-failure' | 'never';
+    video?: 'always' | 'retain-on-failure' | 'never';
+    trace?: 'always' | 'retain-on-failure' | 'never' | 'on-first-failure';
+    bail?: number;
+    workers?: number;
+    ignoreHTTPSErrors?: boolean;
+    acceptDownloads?: boolean;
+    bypassCSP?: boolean;
+}
+export interface PlaywrightNativeResult {
+    success: boolean;
+    duration: number;
+    artifacts?: {
+        screenshots: string[];
+        videos: string[];
+        traces: string[];
+    };
+    error?: string;
+    coverage?: {
+        lines: number;
+        statements: number;
+        branches: number;
+        functions: number;
+    };
+}
+export interface PlaywrightNativeStepResult {
+    step: UiTestStep;
+    success: boolean;
+    duration: number;
+    error?: string;
+    screenshot?: string;
+}
+/**
+ * Playwright Native Adapter
+ *
+ * Provides zero-overhead access to Playwright with automatic
+ * artifact collection (screenshots, videos, traces).
+ */
+export declare class PlaywrightNativeAdapter {
+    private config;
+    private browser?;
+    private context?;
+    private page?;
+    private artifacts?;
+    private assertions?;
+    private testResults;
+    private failureCount;
+    constructor(config: PlaywrightNativeConfig);
+    /**
+     * Run a single E2E test with full Playwright native access
+     */
+    runTest(test: UiTestDefinition): Promise<PlaywrightNativeResult>;
+    /**
+     * Execute a single step using Playwright native API
+     */
+    private executeStep;
+    /**
+     * Execute action using Playwright native API
+     */
+    private executeAction;
+    /**
+     * Setup browser with trace context
+     */
+    private setup;
+    /**
+     * Teardown and save artifacts
+     */
+    private teardown;
+    /**
+     * Get artifact paths for result
+     */
+    private getArtifactPaths;
+    /**
+     * Get direct access to Playwright objects
+     */
+    getBrowser(): Browser | undefined;
+    getContext(): BrowserContext | undefined;
+    getPage(): Page | undefined;
+    /**
+     * Get locator for direct manipulation
+     */
+    locator(selector: string): Locator;
+}
+/**
+ * Create a Playwright Native Adapter
+ */
+export declare function createPlaywrightNativeAdapter(config: PlaywrightNativeConfig): PlaywrightNativeAdapter;
+/**
+ * Create adapter from WebTarget (convenience function)
+ */
+export declare function createFromTarget(target: WebTarget, options?: Partial<PlaywrightNativeConfig>): PlaywrightNativeAdapter;

package/dist/core/adapters/playwright-native-adapter.js

@@ -0,0 +1,339 @@
+/**
+ * QA360 Playwright Native Adapter
+ *
+ * Zero-overhead adapter that uses Playwright's native API directly.
+ * This bypasses any wrapper logic and gives full access to Playwright's capabilities.
+ *
+ * Benefits:
+ * - Zero performance overhead
+ * - Full Playwright API access
+ * - Native video/trace/screenshot support
+ * - Direct access to browser context, page, locators
+ */
+import { chromium, firefox, webkit } from '@playwright/test';
+import { UIArtifactsManager } from '../artifacts/ui-artifacts.js';
+import { createAssertionsEngine } from '../assertions/index.js';
+/**
+ * Playwright Native Adapter
+ *
+ * Provides zero-overhead access to Playwright with automatic
+ * artifact collection (screenshots, videos, traces).
+ */
+export class PlaywrightNativeAdapter {
+    config;
+    browser;
+    context;
+    page;
+    artifacts;
+    assertions;
+    // Test state tracking
+    testResults = new Map();
+    failureCount = 0;
+    constructor(config) {
+        this.config = config;
+        // Initialize artifacts manager
+        this.artifacts = new UIArtifactsManager('.qa360/artifacts/playwright-native', '.qa360/runs/cas');
+    }
+    /**
+     * Run a single E2E test with full Playwright native access
+     */
+    async runTest(test) {
+        const startTime = Date.now();
+        const testId = test.name || 'unknown';
+        this.artifacts?.startTest(testId);
+        this.testResults.set(testId, []);
+        try {
+            // Setup browser with trace context if enabled
+            await this.setup();
+            // Navigate to start URL
+            const startUrl = test.url || `${this.config.target.baseUrl.replace(/\/$/, '')}${test.path || ''}`;
+            await this.page.goto(startUrl, { timeout: this.config.timeout || 30000 });
+            // Initialize assertions engine
+            this.assertions = createAssertionsEngine(this.page);
+            // Take initial screenshot
+            if (this.config.screenshots !== 'never') {
+                await this.artifacts?.takeScreenshot(this.page, {}, {
+                    testId,
+                    type: 'screenshot',
+                    tags: ['initial'],
+                });
+            }
+            // Execute each step
+            for (let i = 0; i < test.steps.length; i++) {
+                const step = test.steps[i];
+                const stepResult = await this.executeStep(step, i);
+                this.testResults.get(testId).push(stepResult);
+                if (!stepResult.success) {
+                    this.failureCount++;
+                    // Check if we should bail
+                    if (this.config.bail && this.failureCount >= this.config.bail) {
+                        throw new Error(`Bail: ${this.failureCount} failures`);
+                    }
+                    // Check if we should continue on failure
+                    const continueOnFailure = step.continueOnError ?? false;
+                    if (!continueOnFailure) {
+                        break;
+                    }
+                }
+                // Screenshot after each step if configured
+                if (this.config.screenshots === 'always' || (this.config.screenshots === 'only-on-failure' && !stepResult.success)) {
+                    await this.artifacts?.takeAfterScreenshot(this.page, step.action || 'step', i, stepResult.success);
+                }
+            }
+            // All steps passed
+            const duration = Date.now() - startTime;
+            return {
+                success: true,
+                duration,
+                artifacts: this.getArtifactPaths(),
+            };
+        }
+        catch (error) {
+            // Take error screenshot
+            if (this.page) {
+                await this.artifacts?.takeErrorScreenshot(this.page, error);
+            }
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error),
+                artifacts: this.getArtifactPaths(),
+            };
+        }
+        finally {
+            this.artifacts?.endTest();
+            await this.teardown();
+        }
+    }
+    /**
+     * Execute a single step using Playwright native API
+     */
+    async executeStep(step, index) {
+        const startTime = Date.now();
+        try {
+            // Take before screenshot if enabled
+            if (this.config.screenshots === 'always') {
+                await this.artifacts?.takeBeforeScreenshot(this.page, step.action || 'step', index);
+            }
+            // Execute action based on type
+            const result = await this.executeAction(step);
+            // Execute assertions if present
+            if (step.assertions && step.assertions.length > 0 && this.assertions) {
+                for (const assertion of step.assertions) {
+                    const assertionResult = await this.assertions.runAssertion(assertion);
+                    if (!assertionResult.passed && !assertion.soft) {
+                        throw new Error(assertionResult.error || `Assertion failed: ${assertion.type}`);
+                    }
+                }
+            }
+            return {
+                step,
+                success: true,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                step,
+                success: false,
+                duration: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Execute action using Playwright native API
+     */
+    async executeAction(step) {
+        const selector = step.selector;
+        const page = this.page;
+        const timeout = step.timeout || this.config.timeout || 30000;
+        // Ensure selector is defined for actions that need it
+        const needsSelector = ['click', 'dblClick', 'rightClick', 'hover', 'focus', 'fill', 'type',
+            'clear', 'select', 'check', 'uncheck', 'press', 'upload', 'tap', 'scroll'].includes(step.action);
+        if (needsSelector && !selector) {
+            throw new Error(`Selector is required for action: ${step.action}`);
+        }
+        switch (step.action) {
+            case 'navigate':
+                await page.goto(step.value || '', { timeout });
+                break;
+            case 'click':
+                await page.click(selector, { timeout });
+                break;
+            case 'dblClick':
+                await page.dblclick(selector, { timeout });
+                break;
+            case 'rightClick':
+                await page.click(selector, { button: 'right', timeout });
+                break;
+            case 'fill':
+            case 'type':
+                if (step.value) {
+                    await page.fill(selector, step.value, { timeout });
+                }
+                break;
+            case 'clear':
+                await page.fill(selector, '', { timeout });
+                break;
+            case 'select':
+                if (step.value !== undefined) {
+                    await page.selectOption(selector, step.value, { timeout });
+                }
+                break;
+            case 'check':
+                await page.check(selector, { timeout });
+                break;
+            case 'uncheck':
+                await page.uncheck(selector, { timeout });
+                break;
+            case 'hover':
+                await page.hover(selector, { timeout });
+                break;
+            case 'focus':
+                await page.focus(selector, { timeout });
+                break;
+            case 'press':
+                if (step.value) {
+                    await page.press(selector, step.value, { timeout });
+                }
+                break;
+            case 'upload':
+                if (step.value) {
+                    await page.setInputFiles(selector, step.value, { timeout });
+                }
+                break;
+            case 'dragAndDrop':
+                if (step.value) {
+                    const source = page.locator(selector);
+                    const target = page.locator(step.value);
+                    await source.dragTo(target, { timeout });
+                }
+                break;
+            case 'scroll':
+                if (selector) {
+                    await page.locator(selector).scrollIntoViewIfNeeded({ timeout });
+                }
+                break;
+            case 'waitFor':
+            case 'waitForSelector':
+                if (selector) {
+                    await page.waitForSelector(selector, {
+                        state: step.value || undefined,
+                        timeout
+                    });
+                }
+                break;
+            case 'waitForTimeout':
+                await page.waitForTimeout(parseInt(step.value || '0', 10) || 0);
+                break;
+            case 'waitForNavigation':
+                await page.waitForNavigation({ timeout });
+                break;
+            case 'tap':
+                await page.tap(selector, { timeout });
+                break;
+            default:
+                throw new Error(`Unknown action: ${step.action}`);
+        }
+    }
+    /**
+     * Setup browser with trace context
+     */
+    async setup() {
+        const browserType = this.config.browser || 'chromium';
+        const browserTypeObj = browserType === 'firefox' ? firefox : browserType === 'webkit' ? webkit : chromium;
+        // Launch browser
+        this.browser = await browserTypeObj.launch({
+            headless: this.config.headless ?? true,
+            slowMo: this.config.slowMo || 0,
+            devtools: this.config.devtools || false,
+        });
+        // Create context with trace recording if enabled
+        const contextOptions = {
+            viewport: this.config.viewport || { width: 1280, height: 720 },
+            userAgent: this.config.userAgent,
+            locale: this.config.locale || 'en-US',
+            timezoneId: this.config.timezone,
+            acceptDownloads: this.config.acceptDownloads ?? true,
+            ignoreHTTPSErrors: this.config.ignoreHTTPSErrors,
+            bypassCSP: this.config.bypassCSP,
+        };
+        // Add video recording
+        if (this.config.video === 'always' || this.config.video === 'retain-on-failure') {
+            contextOptions.recordVideo = {
+                dir: '.qa360/artifacts/playwright-native/videos',
+                size: this.config.viewport || { width: 1280, height: 720 },
+            };
+        }
+        this.context = await this.browser.newContext(contextOptions);
+        // Add tracing if enabled
+        if (this.config.trace === 'always' || this.config.trace === 'on-first-failure' || this.config.trace === 'retain-on-failure') {
+            // Start tracing (Playwright's trace feature)
+            // Note: tracing needs to be started per test
+        }
+        this.page = await this.context.newPage();
+        // Set default timeout
+        this.page.setDefaultTimeout(this.config.timeout || 30000);
+    }
+    /**
+     * Teardown and save artifacts
+     */
+    async teardown() {
+        if (this.page) {
+            // Stop tracing if enabled
+            // Save trace file
+            await this.page.close();
+        }
+        if (this.context) {
+            // Save video if enabled and tests failed
+            if (this.config.video === 'retain-on-failure' && this.failureCount > 0) {
+                // Videos are automatically saved by Playwright
+            }
+            await this.context.close();
+        }
+        if (this.browser) {
+            await this.browser.close();
+        }
+    }
+    /**
+     * Get artifact paths for result
+     */
+    getArtifactPaths() {
+        return {
+            screenshots: [],
+            videos: [],
+            traces: [],
+        };
+    }
+    /**
+     * Get direct access to Playwright objects
+     */
+    getBrowser() { return this.browser; }
+    getContext() { return this.context; }
+    getPage() { return this.page; }
+    /**
+     * Get locator for direct manipulation
+     */
+    locator(selector) {
+        if (!this.page) {
+            throw new Error('Page not initialized. Call setup() first.');
+        }
+        return this.page.locator(selector);
+    }
+}
+/**
+ * Create a Playwright Native Adapter
+ */
+export function createPlaywrightNativeAdapter(config) {
+    return new PlaywrightNativeAdapter(config);
+}
+/**
+ * Create adapter from WebTarget (convenience function)
+ */
+export function createFromTarget(target, options = {}) {
+    return new PlaywrightNativeAdapter({
+        target,
+        ...options,
+    });
+}