qa360 2.2.20 → 2.3.1

package/dist/core/fixtures/factories.js

@@ -0,0 +1,279 @@
+/**
+ * QA360 Fixtures Module
+ *
+ * P0: Reusable test data and factory functions
+ * - Factories for creating test entities
+ * - Fake data generation
+ * - Seeded random for deterministic tests
+ */
+/**
+ * User Factory
+ */
+export class UserFactory {
+    static counter = 1;
+    build(options) {
+        const counter = UserFactory.counter++;
+        const id = options?.overrides?.id || `user-${counter}`;
+        return {
+            id,
+            username: options?.overrides?.username || `user${counter}`,
+            email: options?.overrides?.email || `user${counter}@example.com`,
+            password: options?.overrides?.password || 'TestPassword123!',
+            firstName: options?.overrides?.firstName || 'Test',
+            lastName: options?.overrides?.lastName || `User${counter}`,
+            role: options?.overrides?.role || 'user',
+            active: options?.overrides?.active ?? true,
+            createdAt: options?.overrides?.createdAt || new Date(),
+        };
+    }
+    buildMany(count, options) {
+        return Array.from({ length: count }, () => this.build(options));
+    }
+    /**
+     * Create an admin user
+     */
+    admin(options) {
+        return this.build({
+            ...options,
+            overrides: { ...options?.overrides, role: 'admin' },
+        });
+    }
+    /**
+     * Create an inactive user
+     */
+    inactive(options) {
+        return this.build({
+            ...options,
+            overrides: { ...options?.overrides, active: false },
+        });
+    }
+}
+/**
+ * Test Result Factory
+ */
+export class TestResultFactory {
+    static counter = 1;
+    build(options) {
+        const counter = TestResultFactory.counter++;
+        return {
+            id: options?.overrides?.id || `test-${counter}`,
+            name: options?.overrides?.name || `Test ${counter}`,
+            status: options?.overrides?.status || 'passed',
+            duration: options?.overrides?.duration || 100,
+            error: options?.overrides?.error,
+        };
+    }
+    buildMany(count, options) {
+        return Array.from({ length: count }, () => this.build(options));
+    }
+    /**
+     * Create a passed test
+     */
+    passed(options) {
+        return this.build({
+            ...options,
+            overrides: { ...options?.overrides, status: 'passed' },
+        });
+    }
+    /**
+     * Create a failed test
+     */
+    failed(options) {
+        return this.build({
+            ...options,
+            overrides: {
+                ...options?.overrides,
+                status: 'failed',
+                error: options?.overrides?.error || 'Test failed',
+            },
+        });
+    }
+    /**
+     * Create a skipped test
+     */
+    skipped(options) {
+        return this.build({
+            ...options,
+            overrides: { ...options?.overrides, status: 'skipped' },
+        });
+    }
+}
+/**
+ * API Response Factory
+ */
+export class ApiResponseFactory {
+    build(options) {
+        return {
+            status: options?.overrides?.status || 200,
+            data: options?.overrides?.data,
+            error: options?.overrides?.error,
+            headers: options?.overrides?.headers || {},
+        };
+    }
+    buildMany(count, options) {
+        return Array.from({ length: count }, () => this.build(options));
+    }
+    /**
+     * Create a success response
+     */
+    success(data, options) {
+        return this.build({
+            ...options,
+            overrides: { ...options?.overrides, status: 200, data },
+        });
+    }
+    /**
+     * Create an error response
+     */
+    error(status = 500, message, options) {
+        return this.build({
+            ...options,
+            overrides: {
+                ...options?.overrides,
+                status,
+                error: message || 'Internal Server Error',
+            },
+        });
+    }
+    /**
+     * Create a not found response
+     */
+    notFound(options) {
+        return this.error(404, 'Not Found', options);
+    }
+    /**
+     * Create an unauthorized response
+     */
+    unauthorized(options) {
+        return this.error(401, 'Unauthorized', options);
+    }
+}
+/**
+ * Fake data generator with seeded random
+ */
+export class FakeData {
+    static seed = 12345;
+    /**
+     * Set the seed for deterministic random generation
+     */
+    static setSeed(seed) {
+        this.seed = seed;
+    }
+    /**
+     * Seeded random number generator (Mulberry32)
+     */
+    static random() {
+        this.seed |= 0;
+        this.seed = this.seed + 0x6D2B79F5;
+        let t = this.seed;
+        t = Math.imul(t ^ t >>> 15, t | 1);
+        t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+        return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    }
+    /**
+     * Generate a random integer between min and max (inclusive)
+     */
+    static integer(min, max) {
+        return Math.floor(this.random() * (max - min + 1)) + min;
+    }
+    /**
+     * Generate a random float between min and max
+     */
+    static float(min, max) {
+        return this.random() * (max - min) + min;
+    }
+    /**
+     * Generate a random string
+     */
+    static string(length = 10, charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') {
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            result += charset[Math.floor(this.random() * charset.length)];
+        }
+        return result;
+    }
+    /**
+     * Generate a random email
+     */
+    static email() {
+        const username = this.string(8).toLowerCase();
+        const domains = ['example.com', 'test.com', 'demo.com', 'mail.com'];
+        const domain = domains[this.integer(0, domains.length - 1)];
+        return `${username}@${domain}`;
+    }
+    /**
+     * Generate a random URL
+     */
+    static url() {
+        const paths = ['users', 'posts', 'comments', 'products', 'orders'];
+        const path = paths[this.integer(0, paths.length - 1)];
+        const id = this.integer(1, 1000);
+        return `https://example.com/${path}/${id}`;
+    }
+    /**
+     * Generate a random UUID v4
+     */
+    static uuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = (this.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    /**
+     * Generate a random date
+     */
+    static date(minYear = 2020, maxYear = 2030) {
+        const year = this.integer(minYear, maxYear);
+        const month = this.integer(0, 11);
+        const day = this.integer(1, 28);
+        return new Date(year, month, day);
+    }
+    /**
+     * Generate a random boolean
+     */
+    static boolean() {
+        return this.random() > 0.5;
+    }
+    /**
+     * Pick a random element from an array
+     */
+    static pick(array) {
+        return array[this.integer(0, array.length - 1)];
+    }
+    /**
+     * Generate a random name
+     */
+    static name() {
+        const firstNames = ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank', 'Grace', 'Henry'];
+        const lastNames = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis'];
+        return `${this.pick(firstNames)} ${this.pick(lastNames)}`;
+    }
+    /**
+     * Generate a random paragraph
+     */
+    static paragraph(sentences = 3) {
+        const words = [
+            'lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur', 'adipiscing', 'elit',
+            'sed', 'do', 'eiusmod', 'tempor', 'incididunt', 'ut', 'labore', 'et', 'dolore',
+            'magna', 'aliqua', 'ut', 'enim', 'ad', 'minim', 'veniam', 'quis', 'nostrud',
+        ];
+        const result = [];
+        for (let i = 0; i < sentences; i++) {
+            const sentenceWords = this.integer(5, 15);
+            const sentence = [];
+            for (let j = 0; j < sentenceWords; j++) {
+                sentence.push(this.pick(words));
+            }
+            sentence[0] = sentence[0].charAt(0).toUpperCase() + sentence[0].slice(1);
+            result.push(sentence.join(' ') + '.');
+        }
+        return result.join(' ');
+    }
+}
+/**
+ * Convenience functions
+ */
+export const userFactory = new UserFactory();
+export const testResultFactory = new TestResultFactory();
+export const apiResponseFactory = new ApiResponseFactory();

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

@@ -0,0 +1,6 @@
+/**
+ * QA360 Fixtures Module
+ *
+ * P0: Reusable test data and factory functions
+ */
+export { UserFactory, TestResultFactory, ApiResponseFactory, FakeData, userFactory, testResultFactory, apiResponseFactory, type User, type TestResult, type ApiResponse, type Factory, type FactoryOptions, } from './factories.js';

package/dist/core/fixtures/index.js

@@ -0,0 +1,6 @@
+/**
+ * QA360 Fixtures Module
+ *
+ * P0: Reusable test data and factory functions
+ */
+export { UserFactory, TestResultFactory, ApiResponseFactory, FakeData, userFactory, testResultFactory, apiResponseFactory, } from './factories.js';

package/{cli/dist → dist}/core/generation/crawler-pack-generator.d.ts

@@ -1,9 +1,9 @@
 /**
  * QA360 Crawler Pack Generator
  *
- * Crawls a website and generates a complete pack.yml with E2E tests
+ * Crawls a website and generates a complete pack.yml in v2 format
  */
-import type { CrawlOptions, CrawlResult } from '../crawler/index.js';
+import type { CrawlOptions, CrawlResult, CrawlPresetConfig } from '../crawler/index.js';
 /**
  * Crawler Pack Generator Options
  */
@@ -24,9 +24,19 @@ export interface CrawlerPackGeneratorOptions {
     includeSecurity?: boolean;
     /** Custom journey names */
     journeyNames?: Record<string, string>;
+    /** Phase 1: Preset for platform-specific crawling */
+    preset?: CrawlPresetConfig;
+    /** Phase 1: Authentication configuration */
+    auth?: {
+        email?: string;
+        password?: string;
+        url?: string;
+    };
+    /** Phase 1: Scenario to focus on */
+    scenario?: 'login' | 'browse' | 'search' | 'checkout' | 'dashboard' | 'profile';
 }
 /**
- * Generate pack.yml from crawled website
+ * Generate pack.yml from crawled website (Phase 1: Enhanced with preset and auth support)
  */
 export declare function generatePackFromCrawl(options: CrawlerPackGeneratorOptions): Promise<{
     success: boolean;

package/dist/core/generation/crawler-pack-generator.js

@@ -0,0 +1,232 @@
+/**
+ * QA360 Crawler Pack Generator
+ *
+ * Crawls a website and generates a complete pack.yml in v2 format
+ */
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { crawlWebsite } from '../crawler/index.js';
+/**
+ * Generate pack.yml from crawled website (Phase 1: Enhanced with preset and auth support)
+ */
+export async function generatePackFromCrawl(options) {
+    try {
+        console.log(`🕷️  Crawling ${options.baseUrl}...`);
+        // Build auth options if provided
+        let authConfig;
+        if (options.auth?.email && options.auth?.password) {
+            authConfig = {
+                type: 'form',
+                email: options.auth.email,
+                password: options.auth.password,
+                // Only set loginUrl if user explicitly provided one
+                // Otherwise let the crawler intelligently detect the login page
+                ...(options.auth.url && {
+                    loginUrl: options.auth.url.startsWith('/')
+                        ? `${new URL(options.baseUrl).origin}${options.auth.url}`
+                        : options.auth.url
+                }),
+            };
+        }
+        // Crawl the website with preset and auth (Phase 1)
+        const crawlResult = await crawlWebsite({
+            baseUrl: options.baseUrl,
+            maxDepth: options.crawl?.maxDepth || 2,
+            maxPages: options.crawl?.maxPages || 20,
+            headless: options.crawl?.headless ?? true,
+            screenshots: false,
+            timeout: 30000,
+            excludePatterns: options.crawl?.excludePatterns,
+            onlyPatterns: options.crawl?.onlyPatterns,
+            preset: options.preset,
+            auth: authConfig,
+            scenario: options.scenario,
+        });
+        if (!crawlResult.success) {
+            return {
+                success: false,
+                result: crawlResult,
+                error: 'Crawling failed',
+            };
+        }
+        console.log(`  ✅ Discovered ${crawlResult.siteMap.metadata.pagesCrawled} pages`);
+        console.log(`  ✅ Found ${crawlResult.forms.length} forms`);
+        console.log(`  ✅ Generated ${crawlResult.userJourneys.length} user journeys`);
+        // Generate pack.yml
+        const pack = generatePackFromCrawlResult(crawlResult, options);
+        // Write pack file
+        const packPath = options.output || resolve(process.cwd(), 'pack.yml');
+        const packDir = dirname(packPath);
+        if (!existsSync(packDir)) {
+            mkdirSync(packDir, { recursive: true });
+        }
+        writeFileSync(packPath, pack, 'utf-8');
+        console.log(`\n📦 Generated pack: ${packPath}`);
+        return {
+            success: true,
+            packPath,
+            result: crawlResult,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Generate pack.yml YAML from crawl result (v2 format)
+ */
+function generatePackFromCrawlResult(crawlResult, options) {
+    const { siteMap, userJourneys, forms } = crawlResult;
+    const packName = options.packName || `${new URL(options.baseUrl).hostname.replace(/\./g, '-')}-tests`;
+    // Build full URLs for pages (filtering out non-HTML resources)
+    const baseUrl = options.baseUrl.replace(/\/$/, '');
+    const htmlPages = siteMap.pages.filter(p => {
+        const url = p.url || p.path;
+        // Only include HTML pages (filter out CSS, JS, images, etc.)
+        return !/\.(css|js|json|xml|pdf|zip|jpg|jpeg|png|gif|svg|ico|woff|woff2|ttf|eot)$/i.test(url);
+    });
+    const pages = htmlPages.map(p => `${baseUrl}${p.path.startsWith('/') ? '' : '/'}${p.path}`);
+    // Generate YAML (v2 format)
+    let yaml = `# QA360 Pack v2 - Generated by crawler
+# Source: ${options.baseUrl}
+# Generated: ${new Date().toISOString()}
+
+version: 2
+name: "${packName}"
+description: "Auto-generated E2E tests for ${new URL(options.baseUrl).hostname}"
+
+execution:
+  default_timeout: 30000
+  default_retries: 2
+  on_failure: continue
+
+gates:
+  ui:
+    adapter: playwright-ui
+    enabled: true
+    config:
+      baseUrl: "${options.baseUrl}"
+      pages:
+${pages.map(p => `        - "${p}"`).join('\n')}
+`;
+    // Add a11y gate if requested
+    if (options.includeA11y) {
+        yaml += `
+  a11y:
+    adapter: playwright-ui
+    enabled: true
+    config:
+      baseUrl: "${options.baseUrl}"
+      pages:
+${pages.map(p => `        - "${p}"`).join('\n')}
+      budgets:
+        a11y_min: 80
+`;
+    }
+    // Add journey-based gates if user journeys were generated
+    if (userJourneys.length > 0) {
+        yaml += `
+  # User Journey Tests
+`;
+        for (let i = 0; i < Math.min(userJourneys.length, 5); i++) {
+            const journey = userJourneys[i];
+            const gateName = journey.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+            // Build page objects with actions from journey steps
+            const pageMap = new Map();
+            for (const step of journey.steps) {
+                const stepTyped = step;
+                const url = stepTyped.expected?.url || stepTyped.url;
+                if (url && url !== 'undefined') {
+                    // Convert relative URLs to absolute
+                    const absoluteUrl = url.startsWith('http') ? url : `${baseUrl}${url.startsWith('/') ? '' : '/'}${url}`;
+                    if (!pageMap.has(absoluteUrl)) {
+                        pageMap.set(absoluteUrl, { url: absoluteUrl, actions: [] });
+                    }
+                    // Add action to the page
+                    const page = pageMap.get(absoluteUrl);
+                    const actionType = stepTyped.action || 'navigate';
+                    // Map journey actions to page actions
+                    const pageAction = { type: actionType };
+                    if (stepTyped.selector) {
+                        pageAction.selector = stepTyped.selector;
+                    }
+                    if (stepTyped.value) {
+                        pageAction.value = stepTyped.value;
+                    }
+                    if (stepTyped.wait) {
+                        pageAction.options = { timeout: stepTyped.wait };
+                    }
+                    // Add action if it's meaningful (skip simple navigation)
+                    if (actionType !== 'navigate' || stepTyped.selector || stepTyped.value) {
+                        page.actions.push(pageAction);
+                    }
+                }
+            }
+            // If no pages found, use entry point
+            if (pageMap.size === 0) {
+                pageMap.set(journey.entryPoint, { url: journey.entryPoint, actions: [] });
+            }
+            const pages = Array.from(pageMap.values());
+            // Generate YAML for pages with actions
+            if (pages.every((p) => p.actions.length === 0)) {
+                // No actions, use simple string format
+                yaml += `  journey-${i + 1}-${gateName}:
+    adapter: playwright-ui
+    enabled: true
+    config:
+      baseUrl: "${options.baseUrl}"
+      pages:
+${pages.map((p) => `        - "${p.url}"`).join('\n')}
+      options:
+        timeout: 30000
+`;
+            }
+            else {
+                // Has actions, use object format
+                yaml += `  journey-${i + 1}-${gateName}:
+    adapter: playwright-ui
+    enabled: true
+    config:
+      baseUrl: "${options.baseUrl}"
+      pages:
+${pages.map((p) => {
+                    if (p.actions.length === 0) {
+                        return `        - url: "${p.url}"`;
+                    }
+                    const actionsYaml = p.actions.map((a) => {
+                        let actionLine = `            - type: ${a.type}`;
+                        if (a.selector)
+                            actionLine += `\n              selector: "${a.selector.replace(/"/g, '\\"')}"`;
+                        if (a.value)
+                            actionLine += `\n              value: "${a.value.replace(/"/g, '\\"')}"`;
+                        if (a.options)
+                            actionLine += `\n              options: ${JSON.stringify(a.options)}`;
+                        return actionLine;
+                    }).join('\n');
+                    return `        - url: "${p.url}"\n          actions:\n${actionsYaml}`;
+                }).join('\n')}
+      options:
+        timeout: 30000
+`;
+            }
+        }
+    }
+    return yaml;
+}
+/**
+ * Quick crawl - generates pack without detailed analysis
+ */
+export async function quickCrawl(baseUrl, outputPath) {
+    return generatePackFromCrawl({
+        baseUrl,
+        output: outputPath,
+        crawl: {
+            maxDepth: 1,
+            maxPages: 10,
+        },
+        includeA11y: true,
+    });
+}

package/{cli/dist → dist}/core/generation/index.d.ts

@@ -30,3 +30,5 @@ export type { TestSpec, ApiTestSpec, UiTestSpec, PerfTestSpec, UnitTestSpec, Gen
 export { generateTests, generateApiTestsFromOpenAPI, generateUiTestsFromUrl, generatePerfTests, generateUnitTests, checkGenerationAvailability, } from './generator.js';
 export { generatePackFromCrawl, quickCrawl, } from './crawler-pack-generator.js';
 export type { CrawlerPackGeneratorOptions } from './crawler-pack-generator.js';
+export { PRESETS, getPreset, getAllPresets, detectPresetFromUrl, getPresetList, } from '../crawler/presets.js';
+export type { CrawlerPreset } from '../crawler/presets.js';

package/{cli/dist → dist}/core/generation/index.js

@@ -28,3 +28,5 @@ export { SourceAnalyzer, analyzeSourceFile, analyzeSourceDirectory, generateTest
 export { generateTests, generateApiTestsFromOpenAPI, generateUiTestsFromUrl, generatePerfTests, generateUnitTests, checkGenerationAvailability, } from './generator.js';
 // Crawler Pack Generator (UI Testing 100%)
 export { generatePackFromCrawl, quickCrawl, } from './crawler-pack-generator.js';
+// Universal Crawler Presets
+export { PRESETS, getPreset, getAllPresets, detectPresetFromUrl, getPresetList, } from '../crawler/presets.js';

package/{cli/dist → dist}/core/index.d.ts

@@ -75,6 +75,7 @@ export * from './pack-v2/index.js';
 export { PackLoaderV2, PackValidatorV2, PackLoadResult } from './pack-v2/index.js';
 export type { PackMigrationResultV2, ValidationError } from './pack-v2/index.js';
 export * from './auth/index.js';
+export * from './upload/index.js';
 export * from './generation/index.js';
 export { QA360Server } from './serve/server.js';
 export type { ServeConfig } from './serve/server.js';
@@ -101,6 +102,7 @@ export { HTMLReporter, generateHTMLReport } from './reporting/index.js';
 export type { ReportData, TestReport, StepReport, } from './reporting/index.js';
 export type { ScreenshotArtifact as ReportScreenshotArtifact, VideoArtifact as ReportVideoArtifact, TraceArtifact as ReportTraceArtifact, } from './reporting/index.js';
 export * from './parallel/index.js';
+export * from './sharding/test-sharding.js';
 export * from './visual/index.js';
 export * from './fixtures/index.js';
 export { VitestAdapter } from './adapters/vitest-adapter.js';

package/{cli/dist → dist}/core/index.js

@@ -45,6 +45,8 @@ export * from './pack-v2/index.js';
 export { PackLoaderV2, PackValidatorV2 } from './pack-v2/index.js';
 // Authentication Module
 export * from './auth/index.js';
+// Upload Module (P1 - File upload utilities)
+export * from './upload/index.js';
 // Generation Module (Phase 4 - AI Test Generation)
 export * from './generation/index.js';
 // Server & Observability
@@ -87,6 +89,8 @@ export * from './artifacts/index.js';
 export { HTMLReporter, generateHTMLReport } from './reporting/index.js';
 // Parallel Module (Vision 2.0 - Parallel Test Execution)
 export * from './parallel/index.js';
+// Test Sharding Module (P0 - Split tests across workers)
+export * from './sharding/test-sharding.js';
 // Visual Regression Module (Vision 2.0 - Visual Testing)
 export * from './visual/index.js';
 // Data Fixtures System (v2.2 - Playwright/NFLS best practice)

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

@@ -0,0 +1,7 @@
+/**
+ * QA360 Network Module
+ *
+ * P0 Features: Network simulation and control for testing edge cases
+ */
+export { NetworkSimulator, createNetworkSimulator, simulateNetwork, setOffline, simulateHTTPError, NetworkProfiles, type NetworkSimulationOptions, type HTTPErrorConfig, } from './network-simulator.js';
+export { NetworkManager, createNetworkManager, BlockPatterns, MockResponses, blockAnalytics, mockAllAPI, waitForAPIRequest, waitForAPIResponse, type BlockRouteConfig, type MockRouteConfig, type WaitForRequestOptions, type WaitForResponseOptions, } from './network-manager.js';

package/dist/core/network/index.js

@@ -0,0 +1,7 @@
+/**
+ * QA360 Network Module
+ *
+ * P0 Features: Network simulation and control for testing edge cases
+ */
+export { NetworkSimulator, createNetworkSimulator, simulateNetwork, setOffline, simulateHTTPError, NetworkProfiles, } from './network-simulator.js';
+export { NetworkManager, createNetworkManager, BlockPatterns, MockResponses, blockAnalytics, mockAllAPI, waitForAPIRequest, waitForAPIResponse, } from './network-manager.js';