qa360 1.4.5 → 2.0.1

package/dist/core/adapters/playwright-native-api.js

@@ -0,0 +1,461 @@
+/**
+ * QA360 Playwright Native API Adapter
+ *
+ * Uses Playwright's native APIRequestContext for HTTP testing.
+ * No browser launch required - lighter and faster than browser-based approach.
+ *
+ * @see https://playwright.dev/docs/api/class-apirequestcontext
+ *
+ * Benefits over browser-based approach:
+ * - No browser overhead (faster startup, lower memory)
+ * - Direct HTTP requests
+ * - Same API testing capabilities
+ * - Better for CI/CD environments
+ */
+import * as playwright from 'playwright';
+import { SecurityRedactor } from '../security/redactor.js';
+import { ResponseCache, generateCacheKey } from '../cache/lru-cache.js';
+/**
+ * Playwright Native API Adapter
+ *
+ * Uses playwright.request.newContext() for direct HTTP requests
+ * without launching a browser.
+ */
+export class PlaywrightNativeApiAdapter {
+    requestContext;
+    redactor;
+    auth;
+    cache;
+    constructor() {
+        this.redactor = SecurityRedactor.forLogs();
+    }
+    /**
+     * Set authentication credentials for requests
+     */
+    setAuth(credentials) {
+        this.auth = credentials;
+    }
+    /**
+     * Execute API smoke tests using Playwright's native API
+     */
+    async runSmokeTests(config) {
+        try {
+            this.auth = config.auth;
+            // Initialize cache if enabled
+            if (config.cache?.enabled) {
+                this.cache = new ResponseCache({
+                    maxSize: config.cache.maxSize ?? 100,
+                    ttl: config.cache.ttl ?? 300000,
+                    maxSizeBytes: config.cache.maxSizeBytes ?? 10 * 1024 * 1024,
+                    verbose: false
+                });
+                console.log(`📦 Cache enabled: max=${config.cache.maxSize ?? 100}, ttl=${config.cache.ttl ?? 300000}ms`);
+            }
+            await this.setupRequestContext(config);
+            const results = [];
+            const smokeTests = config.target.smoke || [`GET ${config.target.baseUrl}/health -> 200`];
+            console.log(`🌐 Running API smoke tests with Playwright Native (${smokeTests.length} endpoints)`);
+            for (const test of smokeTests) {
+                // Check cache first if enabled
+                const cacheKey = this.cache ? generateCacheKey({
+                    method: test.split(' ')[0],
+                    url: config.target.baseUrl,
+                    headers: this.auth?.headers
+                }) : '';
+                let testResult;
+                if (this.cache) {
+                    testResult = await this.cache.getOrFetch(cacheKey, () => this.executeApiTest(test, config));
+                    const cached = this.cache.has(cacheKey);
+                    const cacheIndicator = cached ? '📦' : '🌐';
+                    if (testResult.success) {
+                        console.log(`  ${cacheIndicator} ✅ ${testResult.method} ${testResult.endpoint} -> ${testResult.status} (${testResult.responseTime}ms)`);
+                    }
+                    else {
+                        const errorMsg = testResult.error || 'Request failed';
+                        const retryInfo = testResult.attempts && testResult.attempts > 1
+                            ? ` (after ${testResult.attempts} attempts)`
+                            : '';
+                        console.log(`  ${cacheIndicator} ❌ ${testResult.method} ${testResult.endpoint} -> ${errorMsg}${retryInfo}`);
+                    }
+                }
+                else {
+                    testResult = await this.executeApiTest(test, config);
+                    if (testResult.success) {
+                        console.log(`  ✅ ${testResult.method} ${testResult.endpoint} -> ${testResult.status} (${testResult.responseTime}ms)`);
+                    }
+                    else {
+                        const errorMsg = testResult.error || 'Request failed';
+                        const retryInfo = testResult.attempts && testResult.attempts > 1
+                            ? ` (after ${testResult.attempts} attempts)`
+                            : '';
+                        console.log(`  ❌ ${testResult.method} ${testResult.endpoint} -> ${errorMsg}${retryInfo}`);
+                    }
+                }
+                results.push(testResult);
+            }
+            const summary = this.calculateSummary(results);
+            const junit = this.generateJUnit(results);
+            let error;
+            if (summary.failed > 0) {
+                const failedTests = results.filter(r => !r.success);
+                const errorMessages = failedTests.map(t => t.error).filter(Boolean);
+                error = errorMessages.length > 0
+                    ? `${summary.failed} endpoint(s) failed: ${errorMessages[0]}${errorMessages.length > 1 ? ` (and ${errorMessages.length - 1} more)` : ''}`
+                    : `${summary.failed} endpoint(s) failed`;
+            }
+            return {
+                success: summary.failed === 0,
+                results,
+                summary,
+                junit,
+                error
+            };
+        }
+        finally {
+            await this.cleanup();
+        }
+    }
+    /**
+     * Setup Playwright APIRequestContext for HTTP requests
+     */
+    async setupRequestContext(config) {
+        const baseOptions = {
+            userAgent: 'QA360-Native-API/1.0',
+        };
+        const headers = {
+            'Accept': 'application/json, text/plain, */*',
+            'Accept-Encoding': 'gzip, deflate, br',
+        };
+        // Add auth headers if provided
+        if (this.auth?.headers) {
+            Object.assign(headers, this.auth.headers);
+        }
+        baseOptions.extraHTTPHeaders = headers;
+        // Add storage state if provided
+        if (config.storageState) {
+            baseOptions.storageState = config.storageState;
+        }
+        // Set timeout
+        if (config.timeout) {
+            baseOptions.timeout = config.timeout;
+        }
+        // Create API request context using Playwright
+        this.requestContext = await playwright.request.newContext(baseOptions);
+        // Set basic auth if provided in config
+        if (config.basicAuth) {
+            // Note: setHTTPCredentials may not exist on APIRequestContext
+            // Using HTTPCredentials via newContext options instead
+            const creds = { username: config.basicAuth.username, password: config.basicAuth.password };
+            // Set in context options - basic auth is handled via headers
+            const authHeader = 'Basic ' + Buffer.from(`${creds.username}:${creds.password}`).toString('base64');
+            headers['Authorization'] = authHeader;
+            baseOptions.extraHTTPHeaders = headers;
+            // Recreate context with auth headers
+            await this.requestContext.dispose();
+            this.requestContext = await playwright.request.newContext(baseOptions);
+        }
+    }
+    /**
+     * Execute single API test with retry logic using native API
+     */
+    async executeApiTest(testSpec, config) {
+        const { method, endpoint, expectedStatus } = this.parseTestSpec(testSpec, config.target.baseUrl);
+        const maxRetries = config.retries || 0;
+        let lastError = '';
+        let lastResponse = null;
+        let attempts = 0;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            attempts++;
+            const startTime = Date.now();
+            try {
+                // Build request options
+                const requestOptions = {
+                    method: method,
+                    timeout: config.timeout || 30000,
+                    failOnStatusCode: false, // Don't throw on non-2xx responses
+                };
+                // Add body for POST/PUT/PATCH (from config)
+                if (['POST', 'PUT', 'PATCH'].includes(method) && config.body) {
+                    requestOptions.data = config.body;
+                }
+                // Make the request using Playwright's native API
+                lastResponse = await this.requestContext.fetch(endpoint, requestOptions);
+                const responseTime = Date.now() - startTime;
+                const status = lastResponse.status();
+                const success = status === expectedStatus;
+                // Get response headers
+                const responseHeaders = lastResponse.headers();
+                const headers = {};
+                for (const [key, value] of Object.entries(responseHeaders)) {
+                    headers[key] = value;
+                }
+                // Get response body safely
+                let body;
+                try {
+                    const contentType = headers['content-type'] || '';
+                    if (contentType.includes('application/json')) {
+                        body = await lastResponse.json();
+                    }
+                    else {
+                        const text = await lastResponse.text();
+                        body = text.substring(0, 500); // Limit body size
+                    }
+                }
+                catch {
+                    body = '[Response body not readable]';
+                }
+                return {
+                    endpoint,
+                    method,
+                    status,
+                    responseTime,
+                    success,
+                    error: success ? undefined : `Expected status ${expectedStatus}, got ${status}`,
+                    headers,
+                    body: this.redactor.redactObject(body),
+                    attempts
+                };
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error.message : 'Unknown error';
+                // Check if this is a retryable error
+                const isRetryable = this.isRetryableError(lastError);
+                if (isRetryable && attempt < maxRetries) {
+                    const waitTime = 1000 * Math.pow(2, attempt); // Exponential backoff
+                    console.log(`    🔄 Retry ${attempt + 1}/${maxRetries} for ${method} ${endpoint} (${lastError}) - waiting ${waitTime}ms`);
+                    await new Promise(resolve => setTimeout(resolve, waitTime));
+                    continue;
+                }
+                break;
+            }
+        }
+        // If we get here, all retries failed or request threw an error
+        return {
+            endpoint,
+            method,
+            status: lastResponse?.status() || 0,
+            responseTime: 0,
+            success: false,
+            error: this.redactor.redact(lastError),
+            attempts
+        };
+    }
+    /**
+     * Parse test specification string
+     * Format: "GET /path -> 200" or "POST /api/users -> 201"
+     */
+    parseTestSpec(spec, baseUrl) {
+        const match = spec.match(/^(\w+)\s+(.+?)\s*->\s*(\d+)$/);
+        if (!match) {
+            throw new Error(`Invalid test spec format: ${spec}. Expected: "METHOD /path -> STATUS"`);
+        }
+        const [, method, path, statusStr] = match;
+        const expectedStatus = parseInt(statusStr, 10);
+        // Build full endpoint URL
+        let endpoint = path;
+        if (!path.startsWith('http')) {
+            endpoint = baseUrl.replace(/\/$/, '') + (path.startsWith('/') ? path : `/${path}`);
+        }
+        return {
+            method: method.toUpperCase(),
+            endpoint,
+            expectedStatus
+        };
+    }
+    /**
+     * Check if error is retryable
+     */
+    isRetryableError(error) {
+        const retryablePatterns = [
+            /ECONNRESET/,
+            /ETIMEDOUT/,
+            /ECONNREFUSED/,
+            /502 Bad Gateway/,
+            /503 Service Unavailable/,
+            /504 Gateway Timeout/,
+            /timeout/i,
+            /network/i,
+            /fetch failed/i,
+            /EPROTO/,
+        ];
+        return retryablePatterns.some(pattern => pattern.test(error));
+    }
+    /**
+     * Calculate test summary
+     */
+    calculateSummary(results) {
+        const total = results.length;
+        const passed = results.filter(r => r.success).length;
+        const failed = total - passed;
+        const avgResponseTime = total > 0 ?
+            Math.round(results.reduce((sum, r) => sum + r.responseTime, 0) / total) : 0;
+        const totalAttempts = results.reduce((sum, r) => sum + (r.attempts || 1), 0);
+        return { total, passed, failed, avgResponseTime, totalAttempts };
+    }
+    /**
+     * Generate JUnit XML fragment
+     */
+    generateJUnit(results) {
+        const summary = this.calculateSummary(results);
+        const timestamp = new Date().toISOString();
+        let junit = `<?xml version="1.0" encoding="UTF-8"?>
+<testsuite name="API Smoke Tests (Playwright Native)" tests="${summary.total}" failures="${summary.failed}" time="${summary.avgResponseTime / 1000}" timestamp="${timestamp}">
+`;
+        for (const result of results) {
+            const testName = `${result.method} ${result.endpoint}`;
+            const time = result.responseTime / 1000;
+            junit += `  <testcase name="${this.escapeXml(testName)}" time="${time}">
+`;
+            if (!result.success) {
+                const failureDetails = {
+                    error: result.error,
+                    status: result.status,
+                    attempts: result.attempts || 1
+                };
+                junit += `    <failure message="${this.escapeXml(result.error || 'Test failed')}">${this.escapeXml(JSON.stringify(failureDetails, null, 2))}</failure>
+`;
+            }
+            junit += `  </testcase>
+`;
+        }
+        junit += `</testsuite>`;
+        return junit;
+    }
+    /**
+     * Escape XML special characters
+     */
+    escapeXml(str) {
+        return str
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+    /**
+     * Cleanup request context
+     */
+    async cleanup() {
+        if (this.requestContext) {
+            await this.requestContext.dispose();
+            this.requestContext = undefined;
+        }
+    }
+    /**
+     * Validate API target configuration
+     */
+    static validateConfig(target) {
+        const errors = [];
+        if (!target.baseUrl) {
+            errors.push('API target requires baseUrl');
+        }
+        else {
+            try {
+                new URL(target.baseUrl);
+            }
+            catch {
+                errors.push('API target baseUrl must be a valid URL');
+            }
+        }
+        if (target.smoke) {
+            for (const test of target.smoke) {
+                if (!/^\w+\s+.+\s*->\s*\d+$/.test(test)) {
+                    errors.push(`Invalid smoke test format: ${test}. Expected: "METHOD /path -> STATUS"`);
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+     * Health check using native API
+     * Quick check if the API is accessible without running full tests
+     */
+    async healthCheck(baseUrl, path = '/health', timeout = 5000) {
+        try {
+            await this.setupRequestContext({
+                target: { baseUrl },
+                timeout
+            });
+            const endpoint = baseUrl.replace(/\/$/, '') + (path.startsWith('/') ? path : `/${path}`);
+            const response = await this.requestContext.fetch(endpoint, {
+                method: 'GET',
+                timeout,
+                failOnStatusCode: false
+            });
+            // Consider 2xx and 3xx as healthy
+            return response.status() >= 200 && response.status() < 400;
+        }
+        catch {
+            return false;
+        }
+        finally {
+            await this.cleanup();
+        }
+    }
+    /**
+     * Get API info (useful for debugging)
+     * Returns version and capabilities
+     */
+    static getCapabilities() {
+        return {
+            adapter: 'playwright-native',
+            browserless: true,
+            features: [
+                'REST API testing',
+                'GraphQL support',
+                'Basic auth',
+                'Bearer token auth',
+                'Custom headers',
+                'Request/response interception',
+                'Retry logic with exponential backoff',
+                'Storage state for cookie persistence',
+                'Timeout configuration',
+                'LRU cache for HTTP responses'
+            ]
+        };
+    }
+    /**
+     * Get cache statistics if cache is enabled
+     */
+    getCacheStats() {
+        if (!this.cache) {
+            return { enabled: false };
+        }
+        return {
+            enabled: true,
+            stats: this.cache.getStats()
+        };
+    }
+    /**
+     * Clear the cache if enabled
+     */
+    clearCache() {
+        if (this.cache) {
+            this.cache.clear();
+            console.log('📦 Cache cleared');
+        }
+    }
+}
+/**
+ * Factory function to create a native API adapter
+ */
+export function createPlaywrightNativeApiAdapter() {
+    return new PlaywrightNativeApiAdapter();
+}
+/**
+ * Error class for native API adapter
+ */
+export class PlaywrightNativeApiError extends Error {
+    code = 'PLAYWRIGHT_NATIVE_API_ERROR';
+    endpoint;
+    method;
+    constructor(message, endpoint, method) {
+        super(message);
+        this.name = 'PlaywrightNativeApiError';
+        this.endpoint = endpoint;
+        this.method = method;
+    }
+}

package/dist/core/adapters/playwright-ui.d.ts

@@ -3,10 +3,12 @@
  * UI smoke tests + accessibility via axe-core
  */
 import { WebTarget, PackBudgets } from '../types/pack-v1.js';
+import { AuthCredentials } from '../auth/index.js';
 export interface UiTestConfig {
     target: WebTarget;
     budgets?: PackBudgets;
     timeout?: number;
+    auth?: AuthCredentials;
     login?: {
         url?: string;
         username?: string;
@@ -59,7 +61,12 @@ export declare class PlaywrightUiAdapter {
     private context?;
     private page?;
     private redactor;
+    private auth?;
     constructor();
+    /**
+     * Set authentication credentials for requests
+     */
+    setAuth(credentials?: AuthCredentials): void;
     /**
      * Execute UI smoke tests with accessibility
      */

package/dist/core/adapters/playwright-ui.js

@@ -9,14 +9,23 @@ export class PlaywrightUiAdapter {
     context;
     page;
     redactor;
+    auth;
     constructor() {
         this.redactor = SecurityRedactor.forLogs();
     }
+    /**
+     * Set authentication credentials for requests
+     */
+    setAuth(credentials) {
+        this.auth = credentials;
+    }
     /**
      * Execute UI smoke tests with accessibility
      */
     async runSmokeTests(config) {
         try {
+            // Store auth config
+            this.auth = config.auth;
             await this.setupBrowser();
             const results = [];
             const pages = config.target.pages || [config.target.baseUrl];
@@ -292,10 +301,29 @@ export class PlaywrightUiAdapter {
             headless: true,
             args: ['--no-sandbox', '--disable-dev-shm-usage']
         });
+        // Build extra HTTP headers with auth
+        const extraHTTPHeaders = {
+            'User-Agent': 'QA360-UI-Smoke/1.0'
+        };
+        if (this.auth?.headers) {
+            Object.assign(extraHTTPHeaders, this.auth.headers);
+        }
         this.context = await this.browser.newContext({
             viewport: { width: 1280, height: 720 },
-            userAgent: 'QA360-UI-Smoke/1.0'
+            userAgent: 'QA360-UI-Smoke/1.0',
+            extraHTTPHeaders
         });
+        // Add cookies from auth credentials after context creation
+        if (this.auth?.cookies && this.auth.cookies.length > 0) {
+            await this.context.addCookies(this.auth.cookies.map(c => ({
+                name: c.name,
+                value: c.value,
+                domain: c.domain || '',
+                path: c.path || '/',
+                httpOnly: c.httpOnly || false,
+                secure: c.secure || false
+            })));
+        }
         this.page = await this.context.newPage();
     }
     /**

package/dist/core/ai/anthropic-provider.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Anthropic LLM Provider
+ *
+ * Provider for Anthropic API (https://api.anthropic.com).
+ * Supports Claude 3.5 Sonnet, Claude 3 Opus, and Claude 3 Haiku.
+ *
+ * Environment variables:
+ * - ANTHROPIC_API_KEY: Required API key
+ * - ANTHROPIC_BASE_URL: Optional base URL (default: https://api.anthropic.com)
+ * - ANTHROPIC_MODEL: Model to use (default: claude-3-5-sonnet-20241022)
+ */
+import type { LLMProvider, GenerationRequest, GenerationResponse } from './index.js';
+export interface AnthropicConfig {
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+    timeout?: number;
+}
+export declare class AnthropicProvider implements LLMProvider {
+    name: string;
+    models: string[];
+    private readonly apiKey;
+    private readonly baseURL;
+    private readonly defaultModel;
+    private readonly timeout;
+    private readonly version;
+    constructor(config?: AnthropicConfig);
+    isAvailable(): Promise<boolean>;
+    generate(request: GenerationRequest): Promise<GenerationResponse>;
+    stream(request: GenerationRequest): AsyncIterable<string>;
+    countTokens(text: string): number;
+    private buildMessages;
+    private extractContent;
+}
+/**
+ * Anthropic-specific error
+ */
+export declare class AnthropicError extends Error {
+    code: string;
+    details?: Record<string, unknown>;
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Create Anthropic provider with default settings
+ */
+export declare function createAnthropicProvider(config?: AnthropicConfig): AnthropicProvider;
+/**
+ * Check if Anthropic is available and configured
+ */
+export declare function checkAnthropicSetup(): Promise<boolean>;