qa360 2.0.11 → 2.0.13

package/dist/core/assertions/types.js

@@ -0,0 +1,37 @@
+/**
+ * QA360 Assertions Engine - Type Definitions
+ *
+ * Comprehensive assertions for UI testing
+ */
+/**
+ * Assertion error
+ */
+export class AssertionError extends Error {
+    assertion;
+    actual;
+    expected;
+    constructor(message, assertion, actual, expected) {
+        super(message);
+        this.name = 'AssertionError';
+        this.assertion = assertion;
+        this.actual = actual;
+        this.expected = expected;
+    }
+    toString() {
+        const expected = this.expected !== undefined ? ` expected: ${JSON.stringify(this.expected)}` : '';
+        const actual = this.actual !== undefined ? ` actual: ${JSON.stringify(this.actual)}` : '';
+        return `${this.message}${expected}${actual}`;
+    }
+}
+/**
+ * Soft assertion collection
+ */
+export class SoftAssertionError extends Error {
+    results;
+    constructor(results) {
+        const failures = results.filter(r => !r.passed);
+        super(`${failures.length} soft assertion(s) failed:\n${failures.map(f => `  - ${f.error || f.assertion.message || f.assertion.type}`).join('\n')}`);
+        this.name = 'SoftAssertionError';
+        this.results = results;
+    }
+}

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

@@ -0,0 +1,57 @@
+/**
+ * QA360 Web Crawler
+ *
+ * Automatically discovers and analyzes web applications for E2E test generation
+ */
+import type { CrawlOptions, CrawlResult, PageDefinition, CrawlProgress, CrawlEventHandler } from './types.js';
+/**
+ * Web Crawler class
+ */
+export declare class WebCrawler {
+    private options;
+    private eventHandler?;
+    private analyzer;
+    private visited;
+    private queue;
+    private pages;
+    private errors;
+    private warnings;
+    private startTime;
+    private readonly defaultOptions;
+    constructor(options: CrawlOptions);
+    /**
+     * Set event handler for progress updates
+     */
+    on(event: CrawlEventHandler): void;
+    /**
+     * Emit event to handler
+     */
+    private emit;
+    /**
+     * Normalize URL for comparison
+     */
+    private normalizeUrl;
+    /**
+     * Check if URL should be excluded
+     */
+    private isExcluded;
+    /**
+     * Start crawling
+     */
+    crawl(): Promise<CrawlResult>;
+    /**
+     * Build site map from crawled pages
+     */
+    private buildSiteMap;
+}
+/**
+ * Crawl a web application and return results
+ */
+export declare function crawlWebsite(options: CrawlOptions): Promise<CrawlResult>;
+/**
+ * Crawl a website with progress callback
+ */
+export declare function crawlWebsiteWithProgress(options: CrawlOptions, onProgress: (progress: CrawlProgress, page?: PageDefinition) => void): Promise<CrawlResult>;
+export * from './types.js';
+export { generateSelector, generateSelectorFromElement } from './selector-generator.js';
+export { generateJourneys } from './journey-generator.js';

package/dist/core/crawler/index.js

@@ -0,0 +1,281 @@
+/**
+ * QA360 Web Crawler
+ *
+ * Automatically discovers and analyzes web applications for E2E test generation
+ */
+import { PageAnalyzer } from './page-analyzer.js';
+import { JourneyGenerator } from './journey-generator.js';
+/**
+ * Web Crawler class
+ */
+export class WebCrawler {
+    options;
+    eventHandler;
+    analyzer;
+    // Crawling state
+    visited = new Set();
+    queue = [];
+    pages = [];
+    errors = [];
+    warnings = [];
+    startTime = 0;
+    // Default options
+    defaultOptions = {
+        baseUrl: '',
+        maxDepth: 3,
+        maxPages: 50,
+        followLinks: true,
+        discoverForms: true,
+        discoverButtons: true,
+        excludePatterns: [],
+        timeout: 30000,
+        screenshots: false,
+        headless: true,
+        waitForNetworkIdle: true,
+    };
+    constructor(options) {
+        this.options = { ...this.defaultOptions, ...options };
+        this.analyzer = new PageAnalyzer(this.options);
+    }
+    /**
+     * Set event handler for progress updates
+     */
+    on(event) {
+        this.eventHandler = event;
+    }
+    /**
+     * Emit event to handler
+     */
+    emit(event, data) {
+        this.eventHandler?.(event, data);
+    }
+    /**
+     * Normalize URL for comparison
+     */
+    normalizeUrl(url) {
+        try {
+            const parsed = new URL(url);
+            // Remove hash and trailing slash
+            return `${parsed.origin}${parsed.pathname.replace(/\/$/, '')}`;
+        }
+        catch {
+            return url;
+        }
+    }
+    /**
+     * Check if URL should be excluded
+     */
+    isExcluded(url) {
+        const normalized = this.normalizeUrl(url);
+        // Check exclude patterns
+        for (const pattern of this.options.excludePatterns || []) {
+            try {
+                const regex = new RegExp(pattern);
+                if (regex.test(normalized) || regex.test(url)) {
+                    return true;
+                }
+            }
+            catch {
+                // Invalid regex, skip
+            }
+        }
+        // Always exclude certain patterns
+        const defaultExcludes = [
+            /\.pdf$/,
+            /\.zip$/,
+            /\.jpg$/,
+            /\.png$/,
+            /\.gif$/,
+            /\.svg$/,
+            /\/api\//,
+            /\/graphql/,
+            /mailto:/,
+            /tel:/,
+            'javascript:',
+            '#',
+        ];
+        for (const exclude of defaultExcludes) {
+            if (typeof exclude === 'string' ? url.includes(exclude) : exclude.test(url)) {
+                return true;
+            }
+        }
+        // Check if external (different origin)
+        try {
+            const baseOrigin = new URL(this.options.baseUrl).origin;
+            const urlOrigin = new URL(url).origin;
+            if (urlOrigin !== baseOrigin) {
+                return true;
+            }
+        }
+        catch {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Start crawling
+     */
+    async crawl() {
+        this.startTime = Date.now();
+        this.visited.clear();
+        this.queue = [];
+        this.pages = [];
+        this.errors = [];
+        this.warnings = [];
+        // Start with base URL
+        const baseUrl = this.normalizeUrl(this.options.baseUrl);
+        this.queue.push({ url: this.options.baseUrl, depth: 0 });
+        this.visited.add(baseUrl);
+        // Crawl loop
+        const maxPages = this.options.maxPages ?? 50;
+        const maxDepth = this.options.maxDepth ?? 3;
+        while (this.queue.length > 0 && this.pages.length < maxPages) {
+            const { url, depth } = this.queue.shift();
+            // Check max depth
+            if (depth > maxDepth) {
+                this.warnings.push(`Skipped ${url} - max depth reached`);
+                continue;
+            }
+            // Emit progress
+            this.emit('page-start', {
+                currentPage: url,
+                completed: this.pages.length,
+                total: Math.min(maxPages, this.pages.length + this.queue.length),
+                progress: (this.pages.length / maxPages) * 100,
+                depth,
+            });
+            // Analyze page
+            try {
+                const page = await this.analyzer.analyze(url, depth);
+                this.pages.push(page);
+                this.emit('page-complete', page);
+                // Add links to queue
+                if ((this.options.followLinks ?? true) && depth < maxDepth) {
+                    for (const link of page.elements.links) {
+                        if (link.internal && !this.visited.has(this.normalizeUrl(link.url))) {
+                            const normalized = this.normalizeUrl(link.url);
+                            if (!this.isExcluded(link.url)) {
+                                this.visited.add(normalized);
+                                this.queue.push({ url: link.url, depth: depth + 1 });
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                this.errors.push({ page: url, error: errorMsg });
+                this.emit('page-error', { page: url, error: errorMsg });
+            }
+        }
+        // Clean up analyzer
+        await this.analyzer.cleanup();
+        // Build site map
+        const siteMap = this.buildSiteMap();
+        // Generate user journeys
+        const journeyGenerator = new JourneyGenerator(siteMap);
+        const userJourneys = journeyGenerator.generateJourneys();
+        // Emit journeys as discovered
+        for (const journey of userJourneys) {
+            this.emit('journey-discovered', journey);
+        }
+        // Collect accessibility issues
+        const accessibilityIssues = this.pages
+            .filter(p => p.accessibility && p.accessibility.score < 90)
+            .map(p => ({
+            page: p.url,
+            score: p.accessibility.score,
+            violations: p.accessibility.violations.filter(v => v.impact !== 'minor'),
+        }));
+        // Collect all forms
+        const forms = this.pages.flatMap(p => p.elements.forms);
+        const duration = Date.now() - this.startTime;
+        this.emit('complete', { duration, pagesFound: this.pages.length });
+        return {
+            success: this.errors.length === 0 || this.pages.length > 0,
+            siteMap,
+            userJourneys,
+            forms,
+            accessibilityIssues,
+            warnings: this.warnings,
+            errors: this.errors,
+        };
+    }
+    /**
+     * Build site map from crawled pages
+     */
+    buildSiteMap() {
+        const baseUrl = this.options.baseUrl;
+        // Group pages by depth
+        const pagesByDepth = {};
+        for (const page of this.pages) {
+            if (!pagesByDepth[page.depth]) {
+                pagesByDepth[page.depth] = [];
+            }
+            pagesByDepth[page.depth].push(page);
+        }
+        // Find orphan pages (no internal links to them)
+        const linkedUrls = new Set();
+        for (const page of this.pages) {
+            for (const link of page.elements.links) {
+                if (link.internal) {
+                    linkedUrls.add(this.normalizeUrl(link.url));
+                }
+            }
+        }
+        const orphans = this.pages.filter(p => !linkedUrls.has(this.normalizeUrl(p.url)) && p.depth > 0);
+        // Page type distribution
+        const pageTypeDistribution = {};
+        for (const page of this.pages) {
+            pageTypeDistribution[page.pageType] = (pageTypeDistribution[page.pageType] || 0) + 1;
+        }
+        // Total counts
+        const totalLinks = this.pages.reduce((sum, p) => sum + p.elements.links.length, 0);
+        const totalForms = this.pages.reduce((sum, p) => sum + p.elements.forms.length, 0);
+        // Calculate stats
+        const avgLoadTime = this.pages.length > 0
+            ? this.pages.reduce((sum, p) => sum + p.loadTime, 0) / this.pages.length
+            : 0;
+        const maxDepth = Math.max(...this.pages.map(p => p.depth));
+        return {
+            baseUrl,
+            pages: this.pages,
+            pagesByDepth,
+            orphans,
+            pageTypeDistribution,
+            totalLinks,
+            totalForms,
+            metadata: {
+                pagesCrawled: this.pages.length,
+                pagesSkipped: this.warnings.length,
+                pagesFailed: this.errors.length,
+                duration: Date.now() - this.startTime,
+                avgLoadTime: Math.round(avgLoadTime),
+                maxDepth,
+            },
+        };
+    }
+}
+/**
+ * Crawl a web application and return results
+ */
+export async function crawlWebsite(options) {
+    const crawler = new WebCrawler(options);
+    return crawler.crawl();
+}
+/**
+ * Crawl a website with progress callback
+ */
+export async function crawlWebsiteWithProgress(options, onProgress) {
+    const crawler = new WebCrawler(options);
+    crawler.on((event, data) => {
+        if (event === 'page-start' || event === 'page-complete') {
+            onProgress(data, event === 'page-complete' ? data : undefined);
+        }
+    });
+    return crawler.crawl();
+}
+// Re-export types
+export * from './types.js';
+export { generateSelector, generateSelectorFromElement } from './selector-generator.js';
+export { generateJourneys } from './journey-generator.js';

package/dist/core/crawler/journey-generator.d.ts

@@ -0,0 +1,49 @@
+/**
+ * QA360 Journey Generator
+ *
+ * Automatically generates user journeys from crawled pages
+ */
+import type { SiteMap, UserJourney } from './types.js';
+/**
+ * Journey Generator class
+ */
+export declare class JourneyGenerator {
+    private siteMap;
+    constructor(siteMap: SiteMap);
+    /**
+     * Generate all user journeys from the site map
+     */
+    generateJourneys(): UserJourney[];
+    /**
+     * Generate authentication journeys (login, signup)
+     */
+    private generateAuthJourneys;
+    /**
+     * Generate login flow steps
+     */
+    private generateLoginSteps;
+    /**
+     * Generate signup flow steps
+     */
+    private generateSignupSteps;
+    /**
+     * Generate navigation journeys
+     */
+    private generateNavigationJourneys;
+    /**
+     * Generate form submission journeys
+     */
+    private generateFormJourneys;
+    /**
+     * Generate search journeys
+     */
+    private generateSearchJourneys;
+    /**
+     * Generate transaction journeys (checkout, booking, etc.)
+     */
+    private generateTransactionJourneys;
+}
+/**
+ * Generate journeys from a site map
+ */
+export declare function generateJourneys(siteMap: SiteMap): UserJourney[];