qa360 2.0.11 → 2.0.13

package/dist/core/assertions/engine.js

@@ -0,0 +1,530 @@
+/**
+ * QA360 Assertions Engine
+ *
+ * Executes assertions against Playwright Page objects
+ */
+/**
+ * Assertions Engine class
+ */
+export class AssertionsEngine {
+    page;
+    defaultTimeout;
+    constructor(page, defaultTimeout = 5000) {
+        this.page = page;
+        this.defaultTimeout = defaultTimeout;
+    }
+    /**
+     * Run a single assertion
+     */
+    async runAssertion(assertion) {
+        const startTime = Date.now();
+        const timeout = assertion.timeout ?? this.defaultTimeout;
+        try {
+            let actual;
+            let passed = false;
+            let error;
+            switch (assertion.type) {
+                // Visibility assertions
+                case 'visible':
+                    passed = await this.waitForVisible(assertion.selector, timeout, !assertion.not);
+                    actual = await this.isVisible(assertion.selector);
+                    break;
+                case 'hidden':
+                    passed = await this.waitForHidden(assertion.selector, timeout, !assertion.not);
+                    actual = await this.isHidden(assertion.selector);
+                    break;
+                case 'attached':
+                    actual = await this.isAttached(assertion.selector);
+                    passed = assertion.not ? !actual : actual;
+                    break;
+                case 'detached':
+                    actual = await this.isAttached(assertion.selector);
+                    passed = assertion.not ? actual : !actual;
+                    break;
+                // Text content assertions
+                case 'text':
+                    actual = await this.getTextContent(assertion.selector);
+                    passed = this.compare(actual, assertion.expected, assertion.operator || 'eq');
+                    break;
+                case 'contains':
+                    actual = await this.getTextContent(assertion.selector);
+                    passed = assertion.not
+                        ? !this.contains(actual, assertion.expected)
+                        : this.contains(actual, assertion.expected);
+                    break;
+                case 'matches':
+                    actual = await this.getTextContent(assertion.selector);
+                    passed = this.matches(actual, assertion.expected, assertion.not ?? false);
+                    break;
+                // Value assertions
+                case 'value':
+                    actual = await this.getInputValue(assertion.selector);
+                    passed = this.compare(actual, assertion.expected, assertion.operator || 'eq');
+                    break;
+                case 'empty':
+                    actual = (await this.getTextContent(assertion.selector))?.trim() || '';
+                    passed = assertion.not ? actual !== '' : actual === '';
+                    break;
+                case 'notEmpty':
+                    actual = (await this.getTextContent(assertion.selector))?.trim() || '';
+                    passed = assertion.not ? actual === '' : actual !== '';
+                    break;
+                // Attribute assertions
+                case 'attribute':
+                    actual = await this.getAttribute(assertion.selector, assertion.expected.name);
+                    passed = this.compare(actual, assertion.expected.value, assertion.operator || 'eq');
+                    break;
+                case 'hasAttribute':
+                    actual = await this.hasAttribute(assertion.selector, assertion.expected);
+                    passed = assertion.not ? !actual : actual;
+                    break;
+                case 'class':
+                    actual = await this.getClasses(assertion.selector);
+                    passed = assertion.not
+                        ? !this.contains(actual, assertion.expected)
+                        : this.contains(actual, assertion.expected);
+                    break;
+                case 'href':
+                    actual = await this.getAttribute(assertion.selector, 'href');
+                    passed = this.compare(actual, assertion.expected, assertion.operator || 'eq');
+                    break;
+                case 'src':
+                    actual = await this.getAttribute(assertion.selector, 'src');
+                    passed = this.compare(actual, assertion.expected, assertion.operator || 'eq');
+                    break;
+                case 'placeholder':
+                    actual = await this.getAttribute(assertion.selector, 'placeholder');
+                    passed = this.compare(actual, assertion.expected, assertion.operator || 'eq');
+                    break;
+                case 'id':
+                    actual = await this.getAttribute(assertion.selector, 'id');
+                    passed = this.compare(actual, assertion.expected, assertion.operator || 'eq');
+                    break;
+                case 'tagName':
+                    actual = await this.getTagName(assertion.selector);
+                    passed = this.compare(actual?.toLowerCase(), assertion.expected?.toLowerCase(), assertion.operator || 'eq');
+                    break;
+                // Count assertions
+                case 'count':
+                    actual = await this.count(assertion.selector);
+                    passed = this.compare(actual, assertion.expected, assertion.operator || 'eq');
+                    break;
+                // Page-level assertions
+                case 'url':
+                    actual = this.page.url();
+                    passed = this.compare(actual, assertion.expected, assertion.operator || 'eq');
+                    break;
+                case 'urlContains':
+                    actual = this.page.url();
+                    passed = assertion.not
+                        ? !this.contains(actual, assertion.expected)
+                        : this.contains(actual, assertion.expected);
+                    break;
+                case 'title':
+                    actual = await this.page.title();
+                    passed = this.compare(actual, assertion.expected, assertion.operator || 'eq');
+                    break;
+                case 'titleContains':
+                    actual = await this.page.title();
+                    passed = assertion.not
+                        ? !this.contains(actual, assertion.expected)
+                        : this.contains(actual, assertion.expected);
+                    break;
+                // State assertions
+                case 'enabled':
+                    actual = await this.isEnabled(assertion.selector);
+                    passed = assertion.not ? !actual : actual;
+                    break;
+                case 'disabled':
+                    actual = await this.isEnabled(assertion.selector);
+                    passed = assertion.not ? actual : !actual;
+                    break;
+                case 'checked':
+                    actual = await this.isChecked(assertion.selector);
+                    passed = assertion.not ? !actual : actual;
+                    break;
+                case 'unchecked':
+                    actual = await this.isChecked(assertion.selector);
+                    passed = assertion.not ? actual : !actual;
+                    break;
+                case 'focused':
+                    actual = await this.isFocused(assertion.selector);
+                    passed = assertion.not ? !actual : actual;
+                    break;
+                case 'readOnly':
+                    actual = await this.isReadOnly(assertion.selector);
+                    passed = assertion.not ? !actual : actual;
+                    break;
+                case 'editable':
+                    actual = await this.isReadOnly(assertion.selector);
+                    passed = assertion.not ? actual : !actual;
+                    break;
+                case 'selected':
+                    actual = await this.isSelected(assertion.selector);
+                    passed = assertion.not ? !actual : actual;
+                    break;
+                // CSS assertions
+                case 'css':
+                    actual = await this.getCssProperty(assertion.selector, assertion.expected.property);
+                    passed = this.compare(actual, assertion.expected.value, assertion.operator || 'eq');
+                    break;
+                case 'inViewport':
+                    actual = await this.isInViewport(assertion.selector);
+                    passed = assertion.not ? !actual : actual;
+                    break;
+                case 'boundingBox':
+                    actual = await this.getBoundingBox(assertion.selector);
+                    if (assertion.expected) {
+                        const { x, y, width, height } = assertion.expected;
+                        if (x !== undefined)
+                            passed = this.compare(actual.x, x, assertion.operator || 'eq');
+                        if (y !== undefined)
+                            passed = passed && this.compare(actual.y, y, assertion.operator || 'eq');
+                        if (width !== undefined)
+                            passed = passed && this.compare(actual.width, width, assertion.operator || 'eq');
+                        if (height !== undefined)
+                            passed = passed && this.compare(actual.height, height, assertion.operator || 'eq');
+                    }
+                    else {
+                        passed = actual !== null;
+                    }
+                    break;
+                default:
+                    throw new Error(`Unknown assertion type: ${assertion.type}`);
+            }
+            if (!passed) {
+                error = this.formatError(assertion, actual, assertion.expected);
+            }
+            return {
+                assertion,
+                passed,
+                actual,
+                expected: assertion.expected,
+                error,
+                duration: Date.now() - startTime,
+                timestamp: new Date().toISOString(),
+            };
+        }
+        catch (err) {
+            return {
+                assertion,
+                passed: false,
+                expected: assertion.expected,
+                error: err instanceof Error ? err.message : String(err),
+                duration: Date.now() - startTime,
+                timestamp: new Date().toISOString(),
+            };
+        }
+    }
+    /**
+     * Run multiple assertions
+     */
+    async runAssertions(assertions, options = {}) {
+        const startTime = Date.now();
+        const results = [];
+        const opts = {
+            page: this.page,
+            timeout: this.defaultTimeout,
+            throwOnFailure: false,
+            ...options,
+        };
+        const stopOnFailure = options.stopOnFailure ?? false;
+        const parallel = options.parallel ?? false;
+        if (parallel) {
+            // Run all assertions in parallel
+            const promiseResults = await Promise.all(assertions.map(a => this.runAssertion(a)));
+            results.push(...promiseResults);
+        }
+        else {
+            // Run assertions sequentially
+            for (const assertion of assertions) {
+                const result = await this.runAssertion(assertion);
+                results.push(result);
+                opts.onResult?.(result);
+                if (stopOnFailure && !result.passed && !result.assertion.soft) {
+                    break;
+                }
+            }
+        }
+        const failed = results.filter(r => !r.passed && !r.assertion.soft);
+        const passed = results.length - failed.length;
+        return {
+            name: options.name || 'Assertion Group',
+            results,
+            passed: failed.length === 0,
+            duration: Date.now() - startTime,
+            passedCount: passed,
+            failedCount: failed.length,
+            skippedCount: 0,
+        };
+    }
+    // ========== Helper methods for element state ==========
+    async isVisible(selector) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return false;
+            return await element.isVisible();
+        }
+        catch {
+            return false;
+        }
+    }
+    async waitForVisible(selector, timeout, negate) {
+        try {
+            if (negate) {
+                await this.page.waitForSelector(selector, { state: 'hidden', timeout });
+            }
+            else {
+                await this.page.waitForSelector(selector, { state: 'visible', timeout });
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async isHidden(selector) {
+        return !(await this.isVisible(selector));
+    }
+    async waitForHidden(selector, timeout, negate) {
+        try {
+            if (negate) {
+                await this.page.waitForSelector(selector, { state: 'visible', timeout });
+            }
+            else {
+                await this.page.waitForSelector(selector, { state: 'hidden', timeout });
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async isAttached(selector) {
+        try {
+            const element = await this.page.$(selector);
+            return element !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getTextContent(selector) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return '';
+            return (await element.textContent()) || '';
+        }
+        catch {
+            return '';
+        }
+    }
+    async getInputValue(selector) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return '';
+            return await element.inputValue();
+        }
+        catch {
+            return '';
+        }
+    }
+    async getAttribute(selector, attributeName) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return null;
+            return await element.getAttribute(attributeName);
+        }
+        catch {
+            return null;
+        }
+    }
+    async hasAttribute(selector, attributeName) {
+        const attr = await this.getAttribute(selector, attributeName);
+        return attr !== null;
+    }
+    async getClasses(selector) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return [];
+            const className = await element.getAttribute('class');
+            return className ? className.trim().split(/\s+/) : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    async getTagName(selector) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return null;
+            return await element.evaluate((el) => el.tagName);
+        }
+        catch {
+            return null;
+        }
+    }
+    async count(selector) {
+        try {
+            return await this.page.locator(selector).count();
+        }
+        catch {
+            return 0;
+        }
+    }
+    async isEnabled(selector) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return false;
+            return await element.isEnabled();
+        }
+        catch {
+            return false;
+        }
+    }
+    async isChecked(selector) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return false;
+            return await element.isChecked();
+        }
+        catch {
+            return false;
+        }
+    }
+    async isFocused(selector) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return false;
+            return await element.evaluate((el) => document.activeElement === el);
+        }
+        catch {
+            return false;
+        }
+    }
+    async isReadOnly(selector) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return false;
+            const readOnly = await element.getAttribute('readonly');
+            const disabled = await element.getAttribute('disabled');
+            return readOnly !== null || disabled !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    async isSelected(selector) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return false;
+            return await element.evaluate((el) => el.selected);
+        }
+        catch {
+            return false;
+        }
+    }
+    async getCssProperty(selector, property) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return '';
+            return await element.evaluate((el, prop) => {
+                return window.getComputedStyle(el).getPropertyValue(prop);
+            }, property);
+        }
+        catch {
+            return '';
+        }
+    }
+    async isInViewport(selector) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return false;
+            return await element.isIntersectingViewport();
+        }
+        catch {
+            return false;
+        }
+    }
+    async getBoundingBox(selector) {
+        try {
+            const element = await this.page.$(selector);
+            if (!element)
+                return null;
+            const box = await element.boundingBox();
+            return box || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    // ========== Comparison helpers ==========
+    compare(actual, expected, operator) {
+        switch (operator) {
+            case 'eq':
+                return actual == expected;
+            case 'ne':
+                return actual != expected;
+            case 'gt':
+                return Number(actual) > Number(expected);
+            case 'gte':
+                return Number(actual) >= Number(expected);
+            case 'lt':
+                return Number(actual) < Number(expected);
+            case 'lte':
+                return Number(actual) <= Number(expected);
+            case 'startsWith':
+                return String(actual).startsWith(String(expected));
+            case 'endsWith':
+                return String(actual).endsWith(String(expected));
+            case 'isEmpty':
+                return !actual || actual.toString().trim() === '';
+            case 'notEmpty':
+                return actual && actual.toString().trim() !== '';
+            default:
+                return actual == expected;
+        }
+    }
+    contains(actual, expected) {
+        if (actual === null || actual === undefined)
+            return false;
+        return String(actual).includes(String(expected));
+    }
+    matches(actual, expected, negate) {
+        try {
+            const regex = new RegExp(expected);
+            const matched = regex.test(String(actual));
+            return negate ? !matched : matched;
+        }
+        catch {
+            return false;
+        }
+    }
+    formatError(assertion, actual, expected) {
+        const message = assertion.message || `Assertion "${assertion.type}" failed`;
+        const expectedStr = expected !== undefined ? ` (expected: ${JSON.stringify(expected)})` : '';
+        const actualStr = actual !== undefined ? ` (actual: ${JSON.stringify(actual)})` : '';
+        return `${message}${expectedStr}${actualStr}`;
+    }
+}
+/**
+ * Create an assertions engine
+ */
+export function createAssertionsEngine(page, timeout) {
+    return new AssertionsEngine(page, timeout);
+}
+// Re-export types
+export * from './types.js';

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

@@ -0,0 +1,11 @@
+/**
+ * QA360 Assertions Engine
+ *
+ * Comprehensive assertions for UI testing with Playwright
+ */
+export * from './types.js';
+export * from './engine.js';
+/**
+ * Convenience function to create assertions
+ */
+export { createAssertionsEngine } from './engine.js';

package/dist/core/assertions/index.js

@@ -0,0 +1,11 @@
+/**
+ * QA360 Assertions Engine
+ *
+ * Comprehensive assertions for UI testing with Playwright
+ */
+export * from './types.js';
+export * from './engine.js';
+/**
+ * Convenience function to create assertions
+ */
+export { createAssertionsEngine } from './engine.js';

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

@@ -0,0 +1,121 @@
+/**
+ * QA360 Assertions Engine - Type Definitions
+ *
+ * Comprehensive assertions for UI testing
+ */
+/**
+ * Assertion types
+ */
+export type AssertionType = 'visible' | 'hidden' | 'attached' | 'detached' | 'text' | 'contains' | 'matches' | 'value' | 'attribute' | 'class' | 'count' | 'url' | 'urlContains' | 'title' | 'titleContains' | 'enabled' | 'disabled' | 'checked' | 'unchecked' | 'focused' | 'empty' | 'notEmpty' | 'readOnly' | 'editable' | 'selected' | 'href' | 'src' | 'placeholder' | 'id' | 'tagName' | 'css' | 'boundingBox' | 'inViewport' | 'hasAttribute';
+/**
+ * Assertion operators
+ */
+export type AssertionOperator = 'eq' | 'ne' | 'contains' | 'notContains' | 'matches' | 'notMatches' | 'gt' | 'gte' | 'lt' | 'lte' | 'startsWith' | 'endsWith' | 'isEmpty' | 'notEmpty';
+/**
+ * Assertion definition
+ */
+export interface Assertion {
+    /** Assertion type */
+    type: AssertionType;
+    /** CSS selector for element (not needed for url, title) */
+    selector?: string;
+    /** Expected value */
+    expected?: any;
+    /** Operator for comparison (default: 'eq') */
+    operator?: AssertionOperator;
+    /** Whether to negate the assertion */
+    not?: boolean;
+    /** Timeout in milliseconds (default: 5000) */
+    timeout?: number;
+    /** Assertion message/description */
+    message?: string;
+    /** Whether this is a soft assertion (doesn't stop test) */
+    soft?: boolean;
+}
+/**
+ * Assertion result
+ */
+export interface AssertionResult {
+    /** The assertion that was run */
+    assertion: Assertion;
+    /** Whether the assertion passed */
+    passed: boolean;
+    /** Actual value received */
+    actual?: any;
+    /** Expected value */
+    expected?: any;
+    /** Error message if failed */
+    error?: string;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Timestamp */
+    timestamp: string;
+}
+/**
+ * Assertion suite
+ */
+export interface AssertionSuite {
+    /** Suite name */
+    name: string;
+    /** List of assertions */
+    assertions: Assertion[];
+    /** Run all assertions in parallel */
+    parallel?: boolean;
+    /** Stop on first failure */
+    stopOnFailure?: boolean;
+}
+/**
+ * Assertion run options
+ */
+export interface AssertionRunOptions {
+    /** Playwright Page object */
+    page: any;
+    /** Default timeout for assertions */
+    timeout?: number;
+    /** Whether to throw on failure */
+    throwOnFailure?: boolean;
+    /** Callback for assertion results */
+    onResult?: (result: AssertionResult) => void;
+    /** Stop on first failure */
+    stopOnFailure?: boolean;
+    /** Run assertions in parallel */
+    parallel?: boolean;
+    /** Name for the assertion group */
+    name?: string;
+}
+/**
+ * Assertion error
+ */
+export declare class AssertionError extends Error {
+    assertion: Assertion;
+    actual?: any;
+    expected?: any;
+    constructor(message: string, assertion: Assertion, actual?: any, expected?: any);
+    toString(): string;
+}
+/**
+ * Soft assertion collection
+ */
+export declare class SoftAssertionError extends Error {
+    results: AssertionResult[];
+    constructor(results: AssertionResult[]);
+}
+/**
+ * Assertion group result
+ */
+export interface AssertionGroupResult {
+    /** Group name */
+    name: string;
+    /** Individual results */
+    results: AssertionResult[];
+    /** Overall pass status */
+    passed: boolean;
+    /** Total duration */
+    duration: number;
+    /** Number of passed assertions */
+    passedCount: number;
+    /** Number of failed assertions */
+    failedCount: number;
+    /** Number of skipped assertions */
+    skippedCount: number;
+}