qa360 2.2.20 → 2.3.1

package/dist/core/reporting/junit-reporter.d.ts

@@ -0,0 +1,114 @@
+/**
+ * QA360 JUnit XML Reporter
+ *
+ * P0 Feature: Generates JUnit XML format for CI/CD integration
+ * Compatible with Jenkins, GitLab CI, GitHub Actions, CircleCI, etc.
+ *
+ * JUnit XML schema:
+ * - testsuite: Contains test results
+ * - testcase: Individual test case with status
+ * - failure: Error details for failed tests
+ * - skipped: Skipped test information
+ */
+/**
+ * JUnit XML compatible test case
+ */
+export interface JUnitTestCase {
+    name: string;
+    classname?: string;
+    time: number;
+    failure?: {
+        message: string;
+        type: string;
+        text: string;
+    };
+    error?: {
+        message: string;
+        type: string;
+        text: string;
+    };
+    skipped?: {
+        message?: string;
+    };
+    /**
+     * System output (stdout)
+     */
+    'system-out'?: string;
+    /**
+     * System error (stderr)
+     */
+    'system-err'?: string;
+}
+/**
+ * JUnit XML compatible test suite
+ */
+export interface JUnitTestSuite {
+    name: string;
+    tests: number;
+    failures: number;
+    errors: number;
+    skipped: number;
+    time: number;
+    timestamp: string;
+    hostname?: string;
+    properties?: Record<string, string>;
+    testcases: JUnitTestCase[];
+}
+/**
+ * JUnit XML report options
+ */
+export interface JUnitOptions {
+    /**
+     * Suite name (default: "QA360 Test Suite")
+     */
+    suiteName?: string;
+    /**
+     * Environment properties to include
+     */
+    properties?: Record<string, string>;
+    /**
+     * Include stack traces in failure output
+     */
+    includeStackTrace?: boolean;
+}
+/**
+ * JUnit XML Reporter
+ */
+export declare class JUnitReporter {
+    /**
+     * Generate JUnit XML from test suite data
+     */
+    static generate(suite: JUnitTestSuite, options?: JUnitOptions): string;
+    /**
+     * Generate JUnit XML and write to file
+     */
+    static generateToFile(suite: JUnitTestSuite, outputPath: string, options?: JUnitOptions): void;
+    /**
+     * Convert from ReportData format (used by HTMLReporter)
+     */
+    static fromReportData(data: import('./html-reporter.js').ReportData, options?: JUnitOptions): JUnitTestSuite;
+    /**
+     * Convert from UiSmokeResult format (used by PlaywrightUiAdapter)
+     */
+    static fromUiSmokeResult(result: import('../adapters/playwright-ui.js').UiSmokeResult, suiteName?: string, options?: JUnitOptions): JUnitTestSuite;
+    /**
+     * Merge multiple test suites into a single XML
+     */
+    static generateMerged(suites: JUnitTestSuite[], options?: JUnitOptions): string;
+    /**
+     * Escape special XML characters
+     */
+    private static escapeXml;
+    /**
+     * Format time duration (seconds with 3 decimal places)
+     */
+    private static formatTime;
+}
+/**
+ * Convenience function to generate JUnit XML
+ */
+export declare function generateJUnitReport(suite: JUnitTestSuite, options?: JUnitOptions): string;
+/**
+ * Convenience function to generate JUnit XML and write to file
+ */
+export declare function generateJUnitReportToFile(suite: JUnitTestSuite, outputPath: string, options?: JUnitOptions): void;

package/dist/core/reporting/junit-reporter.js

@@ -0,0 +1,306 @@
+/**
+ * QA360 JUnit XML Reporter
+ *
+ * P0 Feature: Generates JUnit XML format for CI/CD integration
+ * Compatible with Jenkins, GitLab CI, GitHub Actions, CircleCI, etc.
+ *
+ * JUnit XML schema:
+ * - testsuite: Contains test results
+ * - testcase: Individual test case with status
+ * - failure: Error details for failed tests
+ * - skipped: Skipped test information
+ */
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { dirname } from 'path';
+/**
+ * JUnit XML Reporter
+ */
+export class JUnitReporter {
+    /**
+     * Generate JUnit XML from test suite data
+     */
+    static generate(suite, options = {}) {
+        const suiteName = options.suiteName || suite.name || 'QA360 Test Suite';
+        const timestamp = suite.timestamp || new Date().toISOString();
+        const hostname = suite.hostname || 'localhost';
+        let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
+        // Calculate totals from testcases if not provided
+        const totalTests = suite.tests || suite.testcases.length;
+        const totalFailures = suite.failures || suite.testcases.filter(t => t.failure).length;
+        const totalErrors = suite.errors || suite.testcases.filter(t => t.error).length;
+        const totalSkipped = suite.skipped || suite.testcases.filter(t => t.skipped).length;
+        const totalTime = suite.time || suite.testcases.reduce((sum, t) => sum + t.time, 0);
+        xml += `<testsuite`;
+        xml += ` name="${this.escapeXml(suiteName)}"`;
+        xml += ` tests="${totalTests}"`;
+        xml += ` failures="${totalFailures}"`;
+        xml += ` errors="${totalErrors}"`;
+        xml += ` skipped="${totalSkipped}"`;
+        xml += ` time="${this.formatTime(totalTime)}"`;
+        xml += ` timestamp="${timestamp}"`;
+        xml += ` hostname="${this.escapeXml(hostname)}"`;
+        xml += `>\n`;
+        // Properties
+        const allProperties = { ...suite.properties, ...options.properties };
+        if (Object.keys(allProperties).length > 0) {
+            xml += '  <properties>\n';
+            for (const [key, value] of Object.entries(allProperties)) {
+                xml += `    <property name="${this.escapeXml(key)}" value="${this.escapeXml(value)}"/>\n`;
+            }
+            xml += '  </properties>\n';
+        }
+        // Test cases
+        for (const testcase of suite.testcases) {
+            xml += '  <testcase';
+            xml += ` name="${this.escapeXml(testcase.name)}"`;
+            if (testcase.classname) {
+                xml += ` classname="${this.escapeXml(testcase.classname)}"`;
+            }
+            xml += ` time="${this.formatTime(testcase.time)}"`;
+            xml += `>\n`;
+            // Failure
+            if (testcase.failure) {
+                xml += '    <failure';
+                xml += ` message="${this.escapeXml(testcase.failure.message)}"`;
+                xml += ` type="${this.escapeXml(testcase.failure.type)}"`;
+                xml += `><![CDATA[${testcase.failure.text}]]></failure>\n`;
+            }
+            // Error
+            if (testcase.error) {
+                xml += '    <error';
+                xml += ` message="${this.escapeXml(testcase.error.message)}"`;
+                xml += ` type="${this.escapeXml(testcase.error.type)}"`;
+                xml += `><![CDATA[${testcase.error.text}]]></error>\n`;
+            }
+            // Skipped
+            if (testcase.skipped) {
+                xml += '    <skipped';
+                if (testcase.skipped.message) {
+                    xml += ` message="${this.escapeXml(testcase.skipped.message)}"`;
+                }
+                xml += '/>\n';
+            }
+            // System out
+            if (testcase['system-out']) {
+                xml += `    <system-out><![CDATA[${testcase['system-out']}]]></system-out>\n`;
+            }
+            // System err
+            if (testcase['system-err']) {
+                xml += `    <system-err><![CDATA[${testcase['system-err']}]]></system-err>\n`;
+            }
+            xml += '  </testcase>\n';
+        }
+        // Standard output/error for the entire suite
+        /*
+        xml += '  <system-out><![CDATA[]]></system-out>\n';
+        xml += '  <system-err><![CDATA[]]></system-err>\n';
+        */
+        xml += '</testsuite>\n';
+        return xml;
+    }
+    /**
+     * Generate JUnit XML and write to file
+     */
+    static generateToFile(suite, outputPath, options = {}) {
+        const xml = this.generate(suite, options);
+        const dir = dirname(outputPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(outputPath, xml, 'utf-8');
+    }
+    /**
+     * Convert from ReportData format (used by HTMLReporter)
+     */
+    static fromReportData(data, options = {}) {
+        const testcases = data.tests.map(test => {
+            const testcase = {
+                name: test.name,
+                classname: data.title,
+                time: test.duration / 1000, // Convert ms to seconds
+            };
+            if (test.status === 'failed') {
+                testcase.failure = {
+                    message: test.error || 'Test failed',
+                    type: 'AssertionError',
+                    text: test.error || 'Test failed without error message'
+                };
+            }
+            else if (test.status === 'skipped') {
+                testcase.skipped = {
+                    message: 'Test was skipped'
+                };
+            }
+            // Add system output with step details
+            if (test.steps && test.steps.length > 0) {
+                const stepsOutput = test.steps.map((step, i) => `${i + 1}. ${step.name}: ${step.status} (${step.duration}ms)`).join('\n');
+                testcase['system-out'] = stepsOutput;
+            }
+            // Add artifacts info to system output
+            if (test.artifacts) {
+                const artifacts = [];
+                if (test.artifacts.screenshots?.length) {
+                    artifacts.push(`Screenshots: ${test.artifacts.screenshots.join(', ')}`);
+                }
+                if (test.artifacts.video) {
+                    artifacts.push(`Video: ${test.artifacts.video}`);
+                }
+                if (test.artifacts.trace) {
+                    artifacts.push(`Trace: ${test.artifacts.trace}`);
+                }
+                if (artifacts.length > 0) {
+                    testcase['system-out'] = (testcase['system-out'] || '') + '\n' + artifacts.join('\n');
+                }
+            }
+            return testcase;
+        });
+        return {
+            name: options.suiteName || data.title,
+            tests: data.summary.total,
+            failures: data.summary.failed,
+            errors: 0, // ReportData doesn't separate errors from failures
+            skipped: data.summary.skipped,
+            time: data.summary.duration / 1000,
+            timestamp: data.summary.timestamp,
+            hostname: 'localhost',
+            properties: {
+                ...data.environment,
+                ...options.properties
+            },
+            testcases
+        };
+    }
+    /**
+     * Convert from UiSmokeResult format (used by PlaywrightUiAdapter)
+     */
+    static fromUiSmokeResult(result, suiteName = 'UI Smoke Tests', options = {}) {
+        const testcases = result.results.map(r => {
+            const testcase = {
+                name: r.page,
+                classname: suiteName,
+                time: r.loadTime / 1000,
+            };
+            if (!r.success) {
+                testcase.failure = {
+                    message: r.error || 'Page test failed',
+                    type: 'AssertionError',
+                    text: r.error || 'Page test failed without error message'
+                };
+            }
+            // Add accessibility info to system output
+            if (r.accessibility) {
+                testcase['system-out'] = `Accessibility Score: ${r.accessibility.score}%\n`;
+                if (r.accessibility.violations.length > 0) {
+                    testcase['system-out'] += `Violations: ${r.accessibility.violations.map(v => `- ${v.id}: ${v.description} (${v.impact})`).join('\n')}`;
+                }
+            }
+            return testcase;
+        });
+        return {
+            name: suiteName,
+            tests: result.summary.total,
+            failures: result.summary.failed,
+            errors: 0,
+            skipped: 0,
+            time: result.results.reduce((sum, r) => sum + r.loadTime, 0) / 1000,
+            timestamp: new Date().toISOString(),
+            hostname: 'localhost',
+            properties: options.properties,
+            testcases
+        };
+    }
+    /**
+     * Merge multiple test suites into a single XML
+     */
+    static generateMerged(suites, options = {}) {
+        let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
+        xml += '<testsuites>\n';
+        const totalTests = suites.reduce((sum, s) => sum + s.tests, 0);
+        const totalFailures = suites.reduce((sum, s) => sum + s.failures, 0);
+        const totalErrors = suites.reduce((sum, s) => sum + s.errors, 0);
+        const totalSkipped = suites.reduce((sum, s) => sum + s.skipped, 0);
+        const totalTime = suites.reduce((sum, s) => sum + s.time, 0);
+        xml += `  <testsuite`;
+        xml += ` name="${this.escapeXml(options.suiteName || 'QA360 Test Suite')}"`;
+        xml += ` tests="${totalTests}"`;
+        xml += ` failures="${totalFailures}"`;
+        xml += ` errors="${totalErrors}"`;
+        xml += ` skipped="${totalSkipped}"`;
+        xml += ` time="${this.formatTime(totalTime)}"`;
+        xml += `>\n`;
+        for (const suite of suites) {
+            for (const testcase of suite.testcases) {
+                xml += '    <testcase';
+                xml += ` name="${this.escapeXml(testcase.name)}"`;
+                if (testcase.classname) {
+                    xml += ` classname="${this.escapeXml(testcase.classname)}"`;
+                }
+                xml += ` time="${this.formatTime(testcase.time)}"`;
+                const hasContent = testcase.failure || testcase.error || testcase.skipped ||
+                    testcase['system-out'] || testcase['system-err'];
+                if (!hasContent) {
+                    xml += '/>\n';
+                }
+                else {
+                    xml += '>\n';
+                    if (testcase.failure) {
+                        xml += `      <failure message="${this.escapeXml(testcase.failure.message)}"` +
+                            ` type="${this.escapeXml(testcase.failure.type)}"` +
+                            `><![CDATA[${testcase.failure.text}]]></failure>\n`;
+                    }
+                    if (testcase.error) {
+                        xml += `      <error message="${this.escapeXml(testcase.error.message)}"` +
+                            ` type="${this.escapeXml(testcase.error.type)}"` +
+                            `><![CDATA[${testcase.error.text}]]></error>\n`;
+                    }
+                    if (testcase.skipped) {
+                        xml += `      <skipped`;
+                        if (testcase.skipped.message) {
+                            xml += ` message="${this.escapeXml(testcase.skipped.message)}"`;
+                        }
+                        xml += '/>\n';
+                    }
+                    if (testcase['system-out']) {
+                        xml += `      <system-out><![CDATA[${testcase['system-out']}]]></system-out>\n`;
+                    }
+                    if (testcase['system-err']) {
+                        xml += `      <system-err><![CDATA[${testcase['system-err']}]]></system-err>\n`;
+                    }
+                    xml += '    </testcase>\n';
+                }
+            }
+        }
+        xml += '  </testsuite>\n';
+        xml += '</testsuites>\n';
+        return xml;
+    }
+    /**
+     * Escape special XML characters
+     */
+    static escapeXml(str) {
+        return str
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+    /**
+     * Format time duration (seconds with 3 decimal places)
+     */
+    static formatTime(seconds) {
+        return seconds.toFixed(3);
+    }
+}
+/**
+ * Convenience function to generate JUnit XML
+ */
+export function generateJUnitReport(suite, options) {
+    return JUnitReporter.generate(suite, options);
+}
+/**
+ * Convenience function to generate JUnit XML and write to file
+ */
+export function generateJUnitReportToFile(suite, outputPath, options) {
+    JUnitReporter.generateToFile(suite, outputPath, options);
+}

package/{cli/dist → dist}/core/runner/e2e-helpers.d.ts

@@ -67,7 +67,7 @@ export declare const E2E_TARGETS: {
     };
     readonly reqres: {
         readonly url: "https://reqres.in/api";
-        readonly timeout: 5000;
+        readonly timeout: 10000;
         readonly description: "Reqres.in fake REST API";
     };
 };

package/{cli/dist → dist}/core/runner/e2e-helpers.js

@@ -12,7 +12,7 @@
  * @returns Health check result
  */
 export async function healthCheck(url, options = {}) {
-    const { timeout = 5000, method = 'HEAD', expectedStatus = [200, 301, 302, 304] } = options;
+    const { timeout = 10000, method = 'HEAD', expectedStatus = [200, 301, 302, 304] } = options;
     const startTime = Date.now();
     try {
         const controller = new AbortController();
@@ -97,7 +97,7 @@ export const E2E_TARGETS = {
     },
     reqres: {
         url: 'https://reqres.in/api',
-        timeout: 5000,
+        timeout: 10000,
         description: 'Reqres.in fake REST API'
     }
 };

package/{cli/dist → dist}/core/runner/phase3-runner.d.ts

@@ -16,6 +16,8 @@ export interface Phase3RunnerOptions {
     flakyDetect?: boolean;
     /** Number of consecutive runs for flakiness detection (default: 3) */
     flakyRuns?: number;
+    /** Run browser in headed mode (visible UI) */
+    headed?: boolean;
 }
 export interface GateResult {
     gate: string;
@@ -64,6 +66,7 @@ export declare class Phase3Runner {
     private flakyDetect;
     private flakyRuns;
     private flakinessDetector;
+    private headed;
     private fixtureLoader?;
     private fixtureResolver?;
     private pageObjectLoader?;

package/{cli/dist → dist}/core/runner/phase3-runner.js

@@ -40,6 +40,7 @@ export class Phase3Runner {
     flakyDetect;
     flakyRuns;
     flakinessDetector;
+    headed; // CLI override for headed mode
     // v2.2.0 Data Fixtures & POM
     fixtureLoader;
     fixtureResolver;
@@ -53,6 +54,7 @@ export class Phase3Runner {
         this.authManager = new AuthManager();
         this.flakyDetect = options.flakyDetect || false;
         this.flakyRuns = options.flakyRuns || DEFAULT_FLAKINESS_OPTIONS.consecutiveRuns;
+        this.headed = options.headed || false;
         this.flakinessDetector = new FlakinessDetector({
             consecutiveRuns: this.flakyRuns,
             minRuns: 2,
@@ -616,40 +618,58 @@ export class Phase3Runner {
         const { PlaywrightUiAdapter } = await import('../adapters/playwright-ui.js');
         const adapter = new PlaywrightUiAdapter();
         // Transform v2 config to adapter format
-        // v2: { baseUrl, pages: [{ url: '/', expectedElements: [...] }] }
-        // adapter expects: { target: { baseUrl, pages: ['https://.../'] } }
+        // v2: { target: { baseUrl, pages, uiTests }, config: { ... } }
+        // adapter expects: { target: { baseUrl, pages, uiTests, ... }, ... }
+        const gateTarget = gateConfig.target || {};
         const gateConfigData = gateConfig.config || {};
         const gateOptions = gateConfig.options || {};
         // Transform page objects to full URLs
-        // v2 pages format: [{ url: '/', expectedElements: [...] }] or ['/', '/about']
-        const rawPages = gateConfigData.pages;
+        // v2 pages format: [{ url: '/', actions: [...] }] or ['/', '/about']
+        // Preserve page objects with actions for user journey execution
+        const rawPages = gateTarget.pages || gateConfigData.pages;
         let pages;
         if (rawPages && Array.isArray(rawPages) && rawPages.length > 0) {
-            const baseUrl = gateConfigData.baseUrl || '';
+            const baseUrl = gateTarget.baseUrl || gateConfigData.baseUrl || '';
             pages = rawPages.map((p) => {
                 if (typeof p === 'string') {
                     // Already a URL string - make it absolute if relative
                     return p.startsWith('http') ? p : `${baseUrl.replace(/\/$/, '')}${p}`;
                 }
                 else if (p && typeof p === 'object' && p.url) {
-                    // Page object { url: '/', ... } - convert to full URL
+                    // Page object { url: '/', actions: [...] } - convert to full URL and preserve actions
                     const url = p.url;
-                    return url.startsWith('http') ? url : `${baseUrl.replace(/\/$/, '')}${url}`;
+                    const absoluteUrl = url.startsWith('http') ? url : `${baseUrl.replace(/\/$/, '')}${url}`;
+                    // Preserve the full page object if it has actions, otherwise return just the URL
+                    return p.actions && p.actions.length > 0
+                        ? { url: absoluteUrl, actions: p.actions }
+                        : absoluteUrl;
                 }
                 return p;
             });
         }
-        else if (gateConfigData.baseUrl) {
-            pages = [gateConfigData.baseUrl];
+        else if (gateTarget.baseUrl || gateConfigData.baseUrl) {
+            pages = [gateTarget.baseUrl || gateConfigData.baseUrl];
         }
+        // Build target config - merge from both target and config sections
+        const targetConfig = {
+            baseUrl: gateTarget.baseUrl || gateConfigData.baseUrl,
+            pages: pages,
+        };
+        // Add uiTests if present in target
+        if (gateTarget.uiTests && Array.isArray(gateTarget.uiTests)) {
+            targetConfig.uiTests = gateTarget.uiTests;
+        }
+        // Add other target properties
+        if (gateTarget.headless !== undefined)
+            targetConfig.headless = gateTarget.headless;
+        if (gateConfigData.headless !== undefined)
+            targetConfig.headless = gateConfigData.headless;
         const config = {
-            target: {
-                baseUrl: gateConfigData.baseUrl,
-                pages: pages
-            },
+            target: targetConfig,
             budgets: gateConfigData.budgets,
             timeout: gateOptions.timeout || gateConfigData.timeout,
             auth: credentials,
+            cliHeaded: this.headed,
             // Playwright++ features
             artifacts: gateConfigData.artifacts,
             htmlReport: gateConfigData.htmlReport,
@@ -881,10 +901,21 @@ export class Phase3Runner {
      * Run UI gate (includes basic accessibility)
      */
     async runUiGate() {
-        const target = this.getTargetWeb();
+        let target = this.getTargetWeb();
         if (!target) {
             throw new Error('UI gate requires targets.web configuration or gate config with baseUrl');
         }
+        // Transform relative pages to full URLs for v1 packs
+        if (target.pages && target.baseUrl && !this.isPackV2(this.pack)) {
+            const baseUrl = target.baseUrl.replace(/\/$/, '');
+            target.pages = target.pages.map((p) => {
+                const pageStr = typeof p === 'object' && p.url ? p.url : p;
+                if (typeof pageStr === 'string' && !pageStr.startsWith('http')) {
+                    return `${baseUrl}${pageStr.startsWith('/') ? '' : '/'}${pageStr}`;
+                }
+                return p;
+            });
+        }
         const credentials = await this.getCredentialsForGate('ui');
         const adapter = new PlaywrightUiAdapter();
         return await adapter.runSmokeTests({