qa360 2.0.11 → 2.0.13

package/dist/commands/run.d.ts

@@ -15,6 +15,7 @@ export interface RunOptions {
     verbose?: boolean;
     dryRun?: boolean;
     strict?: boolean;
+    headed?: boolean;
 }
 /**
  * Unified pack type - can be v1 or v2, Phase3Runner handles both

package/dist/core/adapters/playwright-ui.d.ts

@@ -1,8 +1,8 @@
 /**
- * QA360 Playwright UI Adapter (Socle OOTB)
- * UI smoke tests + accessibility via axe-core
+ * QA360 Playwright UI Adapter (Extended)
+ * Complete UI E2E testing with all Playwright actions
  */
-import { WebTarget, PackBudgets } from '../types/pack-v1.js';
+import type { WebTarget, PackBudgets, UiTestDefinition, UiTestStep } from '../types/pack-v1.js';
 import { AuthCredentials } from '../auth/index.js';
 export interface UiTestConfig {
     target: WebTarget;
@@ -17,6 +17,8 @@ export interface UiTestConfig {
         passwordSelector?: string;
         submitSelector?: string;
     };
+    /** CLI override for headed mode */
+    cliHeaded?: boolean;
 }
 export interface UiTestResult {
     page: string;
@@ -24,6 +26,7 @@ export interface UiTestResult {
     loadTime: number;
     error?: string;
     screenshot?: string;
+    video?: string;
     accessibility?: {
         score: number;
         violations: Array<{
@@ -44,9 +47,24 @@ export interface UiTestResult {
         };
     };
 }
+export interface UiTestStepResult {
+    step: UiTestStep;
+    success: boolean;
+    error?: string;
+    duration: number;
+    screenshot?: string;
+}
+export interface UiE2eResult {
+    test: UiTestDefinition;
+    success: boolean;
+    steps: UiTestStepResult[];
+    duration: number;
+    error?: string;
+}
 export interface UiSmokeResult {
     success: boolean;
     results: UiTestResult[];
+    e2eResults?: UiE2eResult[];
     summary: {
         total: number;
         passed: number;
@@ -62,6 +80,10 @@ export declare class PlaywrightUiAdapter {
     private page?;
     private redactor;
     private auth?;
+    private assertions?;
+    private artifactDir;
+    private videoDir;
+    private traceDir;
     constructor();
     /**
      * Set authentication credentials for requests
@@ -71,10 +93,30 @@ export declare class PlaywrightUiAdapter {
      * Execute UI smoke tests with accessibility
      */
     runSmokeTests(config: UiTestConfig): Promise<UiSmokeResult>;
+    /**
+     * Run a single E2E test
+     */
+    runE2eTest(test: UiTestDefinition, config: UiTestConfig): Promise<UiE2eResult>;
+    /**
+     * Execute a single UI test step
+     */
+    private executeStep;
+    /**
+     * Verify expected outcomes after a step
+     */
+    private verifyExpected;
     /**
      * Test single page with accessibility
      */
     private testPage;
+    /**
+     * Setup browser with all options
+     */
+    private setupBrowser;
+    /**
+     * Determine if video should be recorded
+     */
+    private shouldRecordVideo;
     /**
      * Perform login if configured
      */
@@ -103,10 +145,6 @@ export declare class PlaywrightUiAdapter {
      * Escape XML special characters
      */
     private escapeXml;
-    /**
-     * Setup browser context
-     */
-    private setupBrowser;
     /**
      * Cleanup browser resources
      */

package/dist/core/adapters/playwright-ui.js

@@ -1,17 +1,26 @@
 /**
- * QA360 Playwright UI Adapter (Socle OOTB)
- * UI smoke tests + accessibility via axe-core
+ * QA360 Playwright UI Adapter (Extended)
+ * Complete UI E2E testing with all Playwright actions
  */
-import { chromium } from '@playwright/test';
+import { chromium, firefox, webkit } from '@playwright/test';
 import { SecurityRedactor } from '../security/redactor.js';
+import { createAssertionsEngine } from '../assertions/index.js';
 export class PlaywrightUiAdapter {
     browser;
     context;
     page;
     redactor;
     auth;
+    assertions;
+    // Storage for artifacts
+    artifactDir;
+    videoDir;
+    traceDir;
     constructor() {
         this.redactor = SecurityRedactor.forLogs();
+        this.artifactDir = '.qa360/artifacts/ui';
+        this.videoDir = `${this.artifactDir}/videos`;
+        this.traceDir = `${this.artifactDir}/traces`;
     }
     /**
      * Set authentication credentials for requests
@@ -26,7 +35,7 @@ export class PlaywrightUiAdapter {
         try {
             // Store auth config
             this.auth = config.auth;
-            await this.setupBrowser();
+            await this.setupBrowser(config);
             const results = [];
             const pages = config.target.pages || [config.target.baseUrl];
             console.log(`🖥️  Running UI smoke tests (${pages.length} pages)`);
@@ -46,17 +55,237 @@ export class PlaywrightUiAdapter {
                     console.log(`  ❌ ${pageUrl} -> ${testResult.error}`);
                 }
             }
-            const summary = this.calculateSummary(results);
-            const junit = this.generateJUnit(results);
+            // Run E2E tests if defined
+            let e2eResults = [];
+            if (config.target.uiTests && config.target.uiTests.length > 0) {
+                console.log(`🧪 Running E2E tests (${config.target.uiTests.length} tests)`);
+                for (const test of config.target.uiTests) {
+                    if (test.enabled !== false) {
+                        const result = await this.runE2eTest(test, config);
+                        e2eResults.push(result);
+                        const status = result.success ? '✅' : '❌';
+                        console.log(`  ${status} ${test.name} (${result.duration}ms)`);
+                        if (!result.success) {
+                            console.log(`      Error: ${result.error}`);
+                        }
+                    }
+                }
+            }
+            const summary = this.calculateSummary(results, e2eResults);
+            const junit = this.generateJUnit(results, e2eResults);
             return {
                 success: summary.failed === 0,
                 results,
+                e2eResults,
                 summary,
                 junit
             };
         }
         finally {
-            await this.cleanup();
+            await this.cleanup(config);
+        }
+    }
+    /**
+     * Run a single E2E test
+     */
+    async runE2eTest(test, config) {
+        const startTime = Date.now();
+        const steps = [];
+        try {
+            // Determine starting URL
+            const startUrl = test.url || `${config.target.baseUrl.replace(/\/$/, '')}${test.path || ''}`;
+            // Navigate to start URL
+            console.log(`    📍 Navigate to: ${startUrl}`);
+            await this.page.goto(startUrl, { timeout: test.timeout || config.timeout || 30000 });
+            // Initialize assertions engine
+            this.assertions = createAssertionsEngine(this.page);
+            // Execute each step
+            for (const step of test.steps) {
+                const stepResult = await this.executeStep(step);
+                steps.push(stepResult);
+                if (!stepResult.success) {
+                    return {
+                        test,
+                        success: false,
+                        steps,
+                        duration: Date.now() - startTime,
+                        error: stepResult.error,
+                    };
+                }
+            }
+            return {
+                test,
+                success: true,
+                steps,
+                duration: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                test,
+                success: false,
+                steps,
+                duration: Date.now() - startTime,
+                error: this.redactor.redact(error instanceof Error ? error.message : 'Unknown error'),
+            };
+        }
+    }
+    /**
+     * Execute a single UI test step
+     */
+    async executeStep(step) {
+        const startTime = Date.now();
+        let screenshot;
+        try {
+            const { action, selector, value, options = {}, expected } = step;
+            const opts = { timeout: 5000, ...options };
+            switch (action) {
+                case 'navigate':
+                    await this.page.goto(value, opts);
+                    break;
+                case 'click':
+                    await this.page.click(selector, opts);
+                    break;
+                case 'dblClick':
+                    await this.page.dblclick(selector, opts);
+                    break;
+                case 'rightClick':
+                    await this.page.click(selector, { ...opts, button: 'right' });
+                    break;
+                case 'hover':
+                    await this.page.hover(selector, opts);
+                    break;
+                case 'focus':
+                    await this.page.focus(selector, opts);
+                    break;
+                case 'fill':
+                    await this.page.fill(selector, value, opts);
+                    break;
+                case 'type':
+                    await this.page.type(selector, value, opts);
+                    break;
+                case 'clear':
+                    await this.page.fill(selector, '', opts);
+                    break;
+                case 'select':
+                    if (value !== undefined) {
+                        await this.page.selectOption(selector, value, opts);
+                    }
+                    break;
+                case 'check':
+                    await this.page.check(selector, opts);
+                    break;
+                case 'uncheck':
+                    await this.page.uncheck(selector, opts);
+                    break;
+                case 'upload':
+                    if (value !== undefined) {
+                        await this.page.setInputFiles(selector, value, opts);
+                    }
+                    break;
+                case 'press': {
+                    const delay = options?.delay;
+                    const pressOpts = delay !== undefined ? { delay } : {};
+                    await this.page.keyboard.press(value, pressOpts);
+                    break;
+                }
+                case 'waitFor':
+                case 'waitForSelector':
+                    await this.page.waitForSelector(selector, opts);
+                    break;
+                case 'waitForNavigation':
+                    await this.page.waitForNavigation(opts);
+                    break;
+                case 'waitForTimeout':
+                    await this.page.waitForTimeout(parseInt(value, 10));
+                    break;
+                case 'scroll':
+                    if (selector) {
+                        await this.page.evaluate((sel) => {
+                            const el = document.querySelector(sel);
+                            if (el)
+                                el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+                        }, selector);
+                    }
+                    break;
+                case 'dragAndDrop':
+                    await this.page.dragAndDrop(selector, value, opts);
+                    break;
+                case 'tap':
+                    await this.page.tap(selector, opts);
+                    break;
+                default:
+                    throw new Error(`Unknown action: ${action}`);
+            }
+            // Add wait after action if specified
+            if (step.wait) {
+                await this.page.waitForTimeout(step.wait);
+            }
+            // Take screenshot on failure if configured (will be checked in catch block)
+            // or take screenshot if requested
+            // Verify expected outcomes
+            if (expected) {
+                await this.verifyExpected(expected);
+            }
+            return {
+                step,
+                success: true,
+                duration: Date.now() - startTime,
+                screenshot,
+            };
+        }
+        catch (error) {
+            // Take screenshot on failure
+            try {
+                const buffer = await this.page.screenshot({ type: 'png' });
+                screenshot = `data:image/png;base64,${buffer.toString('base64')}`;
+            }
+            catch { }
+            return {
+                step,
+                success: false,
+                duration: Date.now() - startTime,
+                error: this.redactor.redact(error instanceof Error ? error.message : 'Unknown error'),
+                screenshot,
+            };
+        }
+    }
+    /**
+     * Verify expected outcomes after a step
+     */
+    async verifyExpected(expected) {
+        if (!expected)
+            return;
+        if (expected.url !== undefined) {
+            const currentUrl = this.page.url();
+            if (currentUrl !== expected.url) {
+                throw new Error(`URL mismatch: expected "${expected.url}", got "${currentUrl}"`);
+            }
+        }
+        if (expected.urlContains !== undefined) {
+            const currentUrl = this.page.url();
+            if (!currentUrl.includes(expected.urlContains)) {
+                throw new Error(`URL does not contain "${expected.urlContains}": "${currentUrl}"`);
+            }
+        }
+        if (expected.visible !== undefined) {
+            const element = this.page.locator(expected.visible);
+            if (!(await element.isVisible())) {
+                throw new Error(`Expected element to be visible: ${expected.visible}`);
+            }
+        }
+        if (expected.hidden !== undefined) {
+            const element = this.page.locator(expected.hidden);
+            if (!(await element.isHidden())) {
+                throw new Error(`Expected element to be hidden: ${expected.hidden}`);
+            }
+        }
+        if (expected.elementText) {
+            const element = this.page.locator(expected.elementText.selector);
+            const text = await element.textContent();
+            if (text !== expected.elementText.text) {
+                throw new Error(`Text mismatch for ${expected.elementText.selector}: expected "${expected.elementText.text}", got "${text}"`);
+            }
         }
     }
     /**
@@ -79,8 +308,8 @@ export class PlaywrightUiAdapter {
                     error: `HTTP ${response?.status() || 'unknown'}: Failed to load page`
                 };
             }
-            // Take screenshot
-            const screenshot = await this.takeScreenshot(pageUrl);
+            // Take screenshot based on config
+            const screenshot = await this.takeScreenshot(pageUrl, config.target.screenshot);
             // Get DOM snapshot
             const domSnapshot = await this.getDomSnapshot();
             // Run accessibility tests
@@ -108,6 +337,68 @@ export class PlaywrightUiAdapter {
             };
         }
     }
+    /**
+     * Setup browser with all options
+     */
+    async setupBrowser(config) {
+        // Determine browser type
+        const browserType = config.target.browser || 'chromium';
+        const browserTypeObj = browserType === 'firefox' ? firefox : browserType === 'webkit' ? webkit : chromium;
+        // Determine headed mode (CLI override > target config > default headless)
+        const headless = config.cliHeaded ?? config.target.headless ?? true;
+        // Launch browser
+        this.browser = await browserTypeObj.launch({
+            headless,
+            args: ['--no-sandbox', '--disable-dev-shm-usage'],
+            slowMo: config.target.slowMo || 0,
+        });
+        // Build extra HTTP headers with auth
+        const extraHTTPHeaders = {
+            'User-Agent': 'QA360-UI-Test/1.0'
+        };
+        if (this.auth?.headers) {
+            Object.assign(extraHTTPHeaders, this.auth.headers);
+        }
+        // Setup viewport based on device or explicit config
+        let viewport = { width: 1280, height: 720 };
+        if (config.target.device === 'mobile') {
+            viewport = { width: 375, height: 667 };
+        }
+        else if (config.target.device === 'tablet') {
+            viewport = { width: 768, height: 1024 };
+        }
+        else if (config.target.viewport) {
+            viewport = config.target.viewport;
+        }
+        // Create context with video recording if enabled
+        const recordVideo = this.shouldRecordVideo(config.target.video)
+            ? { dir: this.videoDir, size: viewport }
+            : undefined;
+        this.context = await this.browser.newContext({
+            viewport,
+            userAgent: 'QA360-UI-Test/1.0',
+            extraHTTPHeaders,
+            recordVideo,
+        });
+        // Add cookies from auth credentials after context creation
+        if (this.auth?.cookies && this.auth.cookies.length > 0) {
+            await this.context.addCookies(this.auth.cookies.map(c => ({
+                name: c.name,
+                value: c.value,
+                domain: c.domain || '',
+                path: c.path || '/',
+                httpOnly: c.httpOnly || false,
+                secure: c.secure || false
+            })));
+        }
+        this.page = await this.context.newPage();
+    }
+    /**
+     * Determine if video should be recorded
+     */
+    shouldRecordVideo(mode) {
+        return mode === 'always' || mode === 'retain-on-fail';
+    }
     /**
      * Perform login if configured
      */
@@ -153,7 +444,7 @@ export class PlaywrightUiAdapter {
                         // @ts-ignore
                         axe.run((err, results) => {
                             if (err) {
-                                resolve({ violations: [], passes: [], incomplete: [], inapplicable: [] });
+                                resolve({ violations: [], passes: [], incomplete: [] });
                             }
                             else {
                                 resolve(results);
@@ -161,7 +452,7 @@ export class PlaywrightUiAdapter {
                         });
                     }
                     else {
-                        resolve({ violations: [], passes: [], incomplete: [], inapplicable: [] });
+                        resolve({ violations: [], passes: [], incomplete: [] });
                     }
                 });
             });
@@ -229,7 +520,10 @@ export class PlaywrightUiAdapter {
     /**
      * Take screenshot for debugging
      */
-    async takeScreenshot(pageUrl) {
+    async takeScreenshot(pageUrl, mode) {
+        const shouldTake = mode === 'always' || mode === 'only-on-fail';
+        if (!shouldTake)
+            return '';
         try {
             const screenshot = await this.page.screenshot({
                 type: 'png',
@@ -245,41 +539,77 @@ export class PlaywrightUiAdapter {
     /**
      * Calculate test summary
      */
-    calculateSummary(results) {
-        const total = results.length;
-        const passed = results.filter(r => r.success).length;
+    calculateSummary(results, e2eResults = []) {
+        const smokeTests = results.length;
+        const e2eTests = e2eResults.length;
+        const total = smokeTests + e2eTests;
+        const smokePassed = results.filter(r => r.success).length;
+        const e2ePassed = e2eResults.filter(r => r.success).length;
+        const passed = smokePassed + e2ePassed;
         const failed = total - passed;
-        const avgLoadTime = total > 0 ?
-            Math.round(results.reduce((sum, r) => sum + r.loadTime, 0) / total) : 0;
+        const avgLoadTime = smokeTests > 0 ?
+            Math.round(results.reduce((sum, r) => sum + r.loadTime, 0) / smokeTests) : 0;
         const a11yScores = results
             .map(r => r.accessibility?.score)
             .filter((score) => typeof score === 'number');
         const avgA11yScore = a11yScores.length > 0 ?
             Math.round(a11yScores.reduce((sum, score) => sum + score, 0) / a11yScores.length) : 0;
-        return { total, passed, failed, avgLoadTime, avgA11yScore };
+        return {
+            total,
+            passed,
+            failed,
+            avgLoadTime,
+            avgA11yScore
+        };
     }
     /**
      * Generate JUnit XML fragment
      */
-    generateJUnit(results) {
-        const summary = this.calculateSummary(results);
+    generateJUnit(results, e2eResults = []) {
+        const summary = this.calculateSummary(results, e2eResults);
         const timestamp = new Date().toISOString();
         let junit = `<?xml version="1.0" encoding="UTF-8"?>
-<testsuite name="UI Smoke Tests" tests="${summary.total}" failures="${summary.failed}" time="${summary.avgLoadTime / 1000}" timestamp="${timestamp}">
+<testsuites>
+  <testsuite name="UI Smoke Tests" tests="${results.length}" failures="${results.filter(r => !r.success).length}" time="${summary.avgLoadTime / 1000}" timestamp="${timestamp}">
 `;
         for (const result of results) {
             const testName = `UI Test: ${result.page}`;
             const time = result.loadTime / 1000;
-            junit += `  <testcase name="${this.escapeXml(testName)}" time="${time}">
+            junit += `    <testcase name="${this.escapeXml(testName)}" time="${time}">
 `;
             if (!result.success) {
-                junit += `    <failure message="${this.escapeXml(result.error || 'Test failed')}">${this.escapeXml(JSON.stringify(result, null, 2))}</failure>
+                junit += `      <failure message="${this.escapeXml(result.error || 'Test failed')}">${this.escapeXml(JSON.stringify(result, null, 2))}</failure>
 `;
             }
-            junit += `  </testcase>
+            junit += `    </testcase>
 `;
         }
-        junit += `</testsuite>`;
+        junit += `  </testsuite>
+`;
+        // Add E2E test suite
+        if (e2eResults.length > 0) {
+            const e2eFailed = e2eResults.filter(r => !r.success).length;
+            const e2eDuration = e2eResults.reduce((sum, r) => sum + r.duration, 0) / 1000;
+            junit += `  <testsuite name="E2E Tests" tests="${e2eResults.length}" failures="${e2eFailed}" time="${e2eDuration}" timestamp="${timestamp}">
+`;
+            for (const result of e2eResults) {
+                const testName = result.test.name;
+                const time = result.duration / 1000;
+                junit += `    <testcase name="${this.escapeXml(testName)}" time="${time}">
+`;
+                if (!result.success) {
+                    const failedSteps = result.steps.filter(s => !s.success);
+                    const failureDetails = failedSteps.map(s => `${s.step.action}: ${s.error}`).join('; ');
+                    junit += `      <failure message="${this.escapeXml(result.error || 'Test failed')}">${this.escapeXml(failureDetails)}</failure>
+`;
+                }
+                junit += `    </testcase>
+`;
+            }
+            junit += `  </testsuite>
+`;
+        }
+        junit += `</testsuites>`;
         return junit;
     }
     /**
@@ -293,43 +623,19 @@ export class PlaywrightUiAdapter {
             .replace(/"/g, '&quot;')
             .replace(/'/g, '&apos;');
     }
-    /**
-     * Setup browser context
-     */
-    async setupBrowser() {
-        this.browser = await chromium.launch({
-            headless: true,
-            args: ['--no-sandbox', '--disable-dev-shm-usage']
-        });
-        // Build extra HTTP headers with auth
-        const extraHTTPHeaders = {
-            'User-Agent': 'QA360-UI-Smoke/1.0'
-        };
-        if (this.auth?.headers) {
-            Object.assign(extraHTTPHeaders, this.auth.headers);
-        }
-        this.context = await this.browser.newContext({
-            viewport: { width: 1280, height: 720 },
-            userAgent: 'QA360-UI-Smoke/1.0',
-            extraHTTPHeaders
-        });
-        // Add cookies from auth credentials after context creation
-        if (this.auth?.cookies && this.auth.cookies.length > 0) {
-            await this.context.addCookies(this.auth.cookies.map(c => ({
-                name: c.name,
-                value: c.value,
-                domain: c.domain || '',
-                path: c.path || '/',
-                httpOnly: c.httpOnly || false,
-                secure: c.secure || false
-            })));
-        }
-        this.page = await this.context.newPage();
-    }
     /**
      * Cleanup browser resources
      */
-    async cleanup() {
+    async cleanup(config) {
+        // Save video/trace artifacts if configured
+        if (this.page && (config.target.video === 'retain-on-fail' || config.target.trace === 'retain-on-fail')) {
+            // Check if tests failed and retain artifacts
+            const hasFailures = false; // Would need to track this
+            if (!hasFailures) {
+                // Clean up artifacts if all tests passed
+                // TODO: Implement artifact cleanup
+            }
+        }
         if (this.page) {
             await this.page.close();
         }

package/dist/core/assertions/engine.d.ts

@@ -0,0 +1,51 @@
+/**
+ * QA360 Assertions Engine
+ *
+ * Executes assertions against Playwright Page objects
+ */
+import type { Assertion, AssertionResult, AssertionRunOptions, AssertionGroupResult } from './types.js';
+/**
+ * Assertions Engine class
+ */
+export declare class AssertionsEngine {
+    private page;
+    private defaultTimeout;
+    constructor(page: any, defaultTimeout?: number);
+    /**
+     * Run a single assertion
+     */
+    runAssertion(assertion: Assertion): Promise<AssertionResult>;
+    /**
+     * Run multiple assertions
+     */
+    runAssertions(assertions: Assertion[], options?: Partial<AssertionRunOptions>): Promise<AssertionGroupResult>;
+    private isVisible;
+    private waitForVisible;
+    private isHidden;
+    private waitForHidden;
+    private isAttached;
+    private getTextContent;
+    private getInputValue;
+    private getAttribute;
+    private hasAttribute;
+    private getClasses;
+    private getTagName;
+    private count;
+    private isEnabled;
+    private isChecked;
+    private isFocused;
+    private isReadOnly;
+    private isSelected;
+    private getCssProperty;
+    private isInViewport;
+    private getBoundingBox;
+    private compare;
+    private contains;
+    private matches;
+    private formatError;
+}
+/**
+ * Create an assertions engine
+ */
+export declare function createAssertionsEngine(page: any, timeout?: number): AssertionsEngine;
+export * from './types.js';