qa360 2.1.2 → 2.1.4

package/dist/core/assertions/engine.js

@@ -1,530 +0,0 @@
-/**
- * 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

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,121 +0,0 @@
-/**
- * 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;
-}