qa360 2.2.20 → 2.3.1

package/dist/core/upload/presigned-uploader.js

@@ -0,0 +1,274 @@
+/**
+ * Presigned URL Uploader
+ *
+ * Handles file uploads using presigned URLs for cloud storage.
+ * Supports:
+ * - AWS S3 presigned URLs
+ * - Azure Blob Storage SAS URLs
+ * - Google Cloud Storage signed URLs
+ * - Custom presigned URL providers
+ */
+/**
+ * Presigned URL uploader class
+ */
+export class PresignedUploader {
+    config;
+    constructor(config) {
+        this.config = {
+            presignedUrlEndpoint: config.presignedUrlEndpoint,
+            method: config.method || 'POST',
+            headers: config.headers || {},
+            requestFields: config.requestFields || {},
+            requestParams: config.requestParams || {},
+            fileField: config.fileField || 'file',
+            uploadFields: config.uploadFields || {},
+            uploadMethod: config.uploadMethod || 'PUT',
+            uploadHeaders: config.uploadHeaders || {},
+            onProgress: config.onProgress || (() => { }),
+        };
+    }
+    /**
+     * Upload a file using a presigned URL
+     */
+    async upload(file, fileName) {
+        try {
+            // Step 1: Request presigned URL
+            const presignedResponse = await this.requestPresignedUrl(fileName || file.name || 'upload', file.size, file.type);
+            if (!presignedResponse.url) {
+                return {
+                    success: false,
+                    error: 'No presigned URL received',
+                };
+            }
+            // Step 2: Upload file to presigned URL
+            const uploadResult = await this.uploadToPresignedUrl(file, presignedResponse);
+            if (!uploadResult.success) {
+                return uploadResult;
+            }
+            return {
+                success: true,
+                key: presignedResponse.key,
+                url: presignedResponse.url.split('?')[0], // Remove query params
+                response: uploadResult.response,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Upload failed',
+            };
+        }
+    }
+    /**
+     * Request a presigned URL from the server
+     */
+    async requestPresignedUrl(fileName, fileSize, contentType) {
+        // Build request body
+        const requestBody = {
+            fileName,
+            fileSize,
+            contentType,
+            ...this.config.requestFields,
+        };
+        // Build URL with params
+        let url = this.config.presignedUrlEndpoint;
+        const queryParams = new URLSearchParams(this.config.requestParams).toString();
+        if (queryParams) {
+            url += (url.includes('?') ? '&' : '?') + queryParams;
+        }
+        const response = await fetch(url, {
+            method: this.config.method,
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.config.headers,
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            throw new Error(`Presigned URL request failed: ${response.statusText}`);
+        }
+        const data = await response.json();
+        // Handle different response formats
+        return {
+            url: data.url || data.uploadUrl || data.presignedUrl,
+            method: data.method || this.config.uploadMethod,
+            headers: data.headers || {},
+            fields: data.fields || {},
+            key: data.key || data.fileId || data.id,
+            expiresAt: data.expiresAt,
+        };
+    }
+    /**
+     * Upload file to the presigned URL
+     */
+    async uploadToPresignedUrl(file, presigned) {
+        const method = presigned.method || this.config.uploadMethod;
+        if (method === 'PUT') {
+            return await this.uploadViaPut(file, presigned);
+        }
+        else {
+            return await this.uploadViaPost(file, presigned);
+        }
+    }
+    /**
+     * Upload via PUT request (S3 style)
+     */
+    async uploadViaPut(file, presigned) {
+        const xhr = new XMLHttpRequest();
+        return new Promise((resolve, reject) => {
+            xhr.upload.addEventListener('progress', (e) => {
+                if (e.lengthComputable) {
+                    this.config.onProgress({
+                        loaded: e.loaded,
+                        total: e.total,
+                        percentage: (e.loaded / e.total) * 100,
+                    });
+                }
+            });
+            xhr.addEventListener('load', () => {
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    resolve({
+                        success: true,
+                        response: xhr.response,
+                    });
+                }
+                else {
+                    resolve({
+                        success: false,
+                        error: `Upload failed with status ${xhr.status}`,
+                    });
+                }
+            });
+            xhr.addEventListener('error', () => {
+                resolve({
+                    success: false,
+                    error: 'Network error during upload',
+                });
+            });
+            xhr.open('PUT', presigned.url);
+            // Add required headers
+            const headers = {
+                'Content-Type': file.type || 'application/octet-stream',
+                ...this.config.uploadHeaders,
+                ...presigned.headers,
+            };
+            Object.entries(headers).forEach(([key, value]) => {
+                xhr.setRequestHeader(key, value);
+            });
+            xhr.send(file);
+        });
+    }
+    /**
+     * Upload via POST request (multipart/form-data style)
+     */
+    async uploadViaPost(file, presigned) {
+        const formData = new FormData();
+        // Add file
+        formData.append(this.config.fileField, file);
+        // Add required fields from presigned response
+        Object.entries({ ...presigned.fields, ...this.config.uploadFields }).forEach(([key, value]) => {
+            formData.append(key, value);
+        });
+        const xhr = new XMLHttpRequest();
+        return new Promise((resolve, reject) => {
+            xhr.upload.addEventListener('progress', (e) => {
+                if (e.lengthComputable) {
+                    this.config.onProgress({
+                        loaded: e.loaded,
+                        total: e.total,
+                        percentage: (e.loaded / e.total) * 100,
+                    });
+                }
+            });
+            xhr.addEventListener('load', () => {
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    resolve({
+                        success: true,
+                        response: xhr.response,
+                    });
+                }
+                else {
+                    resolve({
+                        success: false,
+                        error: `Upload failed with status ${xhr.status}`,
+                    });
+                }
+            });
+            xhr.addEventListener('error', () => {
+                resolve({
+                    success: false,
+                    error: 'Network error during upload',
+                });
+            });
+            xhr.open('POST', presigned.url);
+            // Add headers (don't set Content-Type for FormData, browser does it with boundary)
+            Object.entries({ ...presigned.headers, ...this.config.uploadHeaders }).forEach(([key, value]) => {
+                if (key.toLowerCase() !== 'content-type') {
+                    xhr.setRequestHeader(key, value);
+                }
+            });
+            xhr.send(formData);
+        });
+    }
+    /**
+     * Upload multiple files concurrently
+     */
+    async uploadMultiple(files, concurrency = 3) {
+        const results = [];
+        const queue = [...files];
+        const activeUploads = [];
+        while (queue.length > 0) {
+            while (activeUploads.length < concurrency && queue.length > 0) {
+                const file = queue.shift();
+                const uploadPromise = this.upload(file).then((result) => {
+                    results.push(result);
+                    activeUploads.splice(activeUploads.indexOf(uploadPromise), 1);
+                });
+                activeUploads.push(uploadPromise);
+            }
+            await Promise.race(activeUploads);
+        }
+        await Promise.all(activeUploads);
+        return results;
+    }
+}
+/**
+ * Create a presigned URL uploader instance
+ */
+export function createPresignedUploader(config) {
+    return new PresignedUploader(config);
+}
+/**
+ * Upload a file using a presigned URL (convenience function)
+ */
+export async function uploadWithPresignedUrl(file, config) {
+    const uploader = new PresignedUploader(config);
+    return uploader.upload(file);
+}
+/**
+ * AWS S3 specific presigned uploader
+ */
+export class S3PresignedUploader extends PresignedUploader {
+    constructor(config) {
+        super({
+            ...config,
+            uploadMethod: 'PUT',
+            uploadFields: {},
+        });
+    }
+}
+/**
+ * Azure Blob Storage specific presigned uploader
+ */
+export class AzurePresignedUploader extends PresignedUploader {
+    constructor(config) {
+        super({
+            ...config,
+            uploadMethod: 'PUT',
+            uploadHeaders: {
+                'x-ms-blob-type': 'BlockBlob',
+            },
+        });
+    }
+}
+export default PresignedUploader;

package/dist/core/utils/device-emulation.d.ts

@@ -0,0 +1,194 @@
+/**
+ * QA360 Device Emulation Module
+ *
+ * P0: Mobile and tablet device emulation
+ * - Predefined device profiles
+ * - Viewport resizing
+ * - User agent emulation
+ * - Touch/Mouse interaction switching
+ * - Device pixel ratio handling
+ * - Orientation (portrait/landscape)
+ */
+import type { Page } from '@playwright/test';
+/**
+ * Device viewport configuration
+ */
+export interface ViewportConfig {
+    /** Viewport width in pixels */
+    width: number;
+    /** Viewport height in pixels */
+    height: number;
+    /** Device scale factor (default: 1) */
+    deviceScaleFactor?: number;
+    /** Whether to emulate mobile (default: false) */
+    isMobile?: boolean;
+    /** Whether to emulate touch (default: false for desktop, true for mobile) */
+    hasTouch?: boolean;
+    /** Screen orientation */
+    landscape?: boolean;
+}
+/**
+ * Device profile with full configuration
+ */
+export interface DeviceProfile extends ViewportConfig {
+    /** Device name */
+    name: string;
+    /** User agent string */
+    userAgent: string;
+    /** Device category */
+    category: 'desktop' | 'tablet' | 'mobile';
+}
+/**
+ * Orientation options
+ */
+export type Orientation = 'portrait' | 'landscape';
+/**
+ * Device Emulation Helper
+ */
+export declare class DeviceEmulator {
+    private page;
+    private static profiles;
+    constructor(page: Page);
+    /**
+     * Get all available device profiles
+     */
+    static getProfiles(): Record<string, DeviceProfile>;
+    /**
+     * Get a specific device profile
+     */
+    static getProfile(name: string): DeviceProfile | undefined;
+    /**
+     * Get all profiles by category
+     */
+    static getProfilesByCategory(category: 'desktop' | 'tablet' | 'mobile'): DeviceProfile[];
+    /**
+     * Emulate a device by name
+     */
+    emulate(device: string): Promise<void>;
+    /**
+     * Emulate a device profile
+     */
+    emulateProfile(profile: DeviceProfile): Promise<void>;
+    /**
+     * Set viewport size
+     */
+    setViewport(width: number, height: number, options?: Partial<ViewportConfig>): Promise<void>;
+    /**
+     * Set viewport to predefined dimensions
+     */
+    desktop(): Promise<void>;
+    tablet(): Promise<void>;
+    mobile(): Promise<void>;
+    /**
+     * Set screen orientation
+     */
+    setOrientation(orientation: Orientation): Promise<void>;
+    /**
+     * Rotate device (swap width and height)
+     */
+    rotate(): Promise<void>;
+    /**
+     * Set device pixel ratio
+     */
+    setDeviceScaleFactor(dpr: number): Promise<void>;
+    /**
+     * Enable/disable touch emulation
+     */
+    setTouch(enabled: boolean): Promise<void>;
+    /**
+     * Get current viewport info
+     */
+    getViewport(): Promise<ViewportConfig | null>;
+    /**
+     * Test at multiple viewport sizes (responsive testing)
+     */
+    testAtSizes(sizes: Array<{
+        width: number;
+        height: number;
+    }>, testFn: () => Promise<void>): Promise<Array<{
+        size: {
+            width: number;
+            height: number;
+        };
+        passed: boolean;
+        error?: Error;
+    }>>;
+    /**
+     * Test at multiple breakpoints (common responsive sizes)
+     */
+    testResponsive(testFn: () => Promise<void>): Promise<Array<{
+        breakpoint: string;
+        passed: boolean;
+        error?: Error;
+    }>>;
+    /**
+     * Test on multiple device profiles
+     */
+    testOnDevices(devices: string[], testFn: () => Promise<void>): Promise<Array<{
+        device: string;
+        passed: boolean;
+        error?: Error;
+    }>>;
+}
+/**
+ * Convenience function to create device emulator
+ */
+export declare function device(page: Page): DeviceEmulator;
+/**
+ * Common viewport presets
+ */
+export declare const Viewport: {
+    'desktop-xl': {
+        width: number;
+        height: number;
+    };
+    'desktop-lg': {
+        width: number;
+        height: number;
+    };
+    'desktop-md': {
+        width: number;
+        height: number;
+    };
+    'desktop-sm': {
+        width: number;
+        height: number;
+    };
+    'tablet-lg': {
+        width: number;
+        height: number;
+    };
+    'tablet-md': {
+        width: number;
+        height: number;
+    };
+    'tablet-sm': {
+        width: number;
+        height: number;
+    };
+    'mobile-lg': {
+        width: number;
+        height: number;
+    };
+    'mobile-md': {
+        width: number;
+        height: number;
+    };
+    'mobile-sm': {
+        width: number;
+        height: number;
+    };
+    'mobile-xs': {
+        width: number;
+        height: number;
+    };
+};
+/**
+ * Common device lists
+ */
+export declare const Devices: {
+    desktop: readonly ["desktop-1920x1080", "desktop-1366x768", "macbook-16"];
+    tablet: readonly ["ipad-pro", "ipad", "ipad-mini", "surface-pro"];
+    mobile: readonly ["iphone-15-pro-max", "iphone-15-pro", "iphone-se", "pixel-7-pro", "samsung-s23"];
+    popular: readonly ["desktop-1920x1080", "ipad", "iphone-15-pro", "pixel-7-pro"];
+};