qa360 1.4.5 → 2.0.1

package/dist/commands/slo.js

@@ -0,0 +1,327 @@
+/**
+ * QA360 SLO/SLI Command
+ *
+ * CLI command for SLO/SLI management and reporting.
+ */
+import { Command } from 'commander';
+import { SLOTracker, createDefaultSLOConfig, createStrictSLOConfig, createRelaxedSLOConfig, TimeWindows } from '../core/index.js';
+export const sloCommand = new Command('slo');
+sloCommand.description('Service Level Objectives and Indicators management');
+// List all SLOs
+sloCommand
+    .command('list')
+    .description('List all SLOs')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const config = createDefaultSLOConfig();
+    const tracker = new SLOTracker();
+    tracker.registerSLOs(config.slos);
+    const slos = tracker.getAllSLOs();
+    if (options.json) {
+        console.log(JSON.stringify(slos, null, 2));
+        return;
+    }
+    console.log('\n📊 Service Level Objectives\n');
+    if (slos.length === 0) {
+        console.log('No SLOs configured.\n');
+        return;
+    }
+    for (const slo of slos) {
+        const status = slo.status === 'healthy' ? '✓' : slo.status === 'warning' ? '⚠' : '✗';
+        const currentValue = slo.currentValue?.toFixed(2) || 'N/A';
+        console.log(`  ${status} ${slo.name}`);
+        console.log(`      Target: ${slo.target}% | Current: ${currentValue}%`);
+        console.log(`      Window: ${formatDuration(slo.windowMs)}`);
+        console.log(`      Error Budget: ${slo.errorBudget.remainingBudget.toFixed(2)}% remaining`);
+        console.log('');
+    }
+});
+// List all SLIs
+sloCommand
+    .command('sli')
+    .description('List all Service Level Indicators')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const config = createDefaultSLOConfig();
+    const tracker = new SLOTracker();
+    tracker.registerSLIs(config.slis);
+    const slis = tracker.getAllSLIs();
+    if (options.json) {
+        console.log(JSON.stringify(slis, null, 2));
+        return;
+    }
+    console.log('\n📈 Service Level Indicators\n');
+    if (slis.length === 0) {
+        console.log('No SLIs configured.\n');
+        return;
+    }
+    for (const sli of slis) {
+        console.log(`  • ${sli.name}`);
+        console.log(`      Type: ${sli.type}`);
+        console.log(`      Source: ${sli.source}`);
+        console.log(`      Aggregation: ${sli.aggregation}`);
+        console.log(`      Unit: ${sli.unit}`);
+        console.log(`      Threshold: ${sli.threshold.operator} ${sli.threshold.value}${sli.unit === 'percentage' ? '%' : sli.unit}`);
+        console.log('');
+    }
+});
+// Show SLO status
+sloCommand
+    .command('status')
+    .description('Show current SLO status')
+    .option('--id <id>', 'SLO ID (optional, shows all if not specified)')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const config = createDefaultSLOConfig();
+    const tracker = new SLOTracker();
+    tracker.registerSLOs(config.slos);
+    tracker.registerSLIs(config.slis);
+    // Simulate some measurements for demo
+    const demoSli = config.slis[0];
+    if (demoSli) {
+        tracker.recordMeasurement({
+            sliId: demoSli.id,
+            timestamp: Date.now(),
+            value: 92,
+            total: 100,
+            good: 92,
+            bad: 8,
+            unit: demoSli.unit,
+            windowStart: Date.now() - TimeWindows.DAY,
+            windowEnd: Date.now()
+        });
+    }
+    const results = options.id
+        ? [tracker.calculateSLOResult(options.id)]
+        : tracker.calculateAllResults();
+    if (options.json) {
+        console.log(JSON.stringify(results.filter(r => r), null, 2));
+        return;
+    }
+    console.log('\n📊 SLO Status Report\n');
+    console.log(`Generated: ${new Date().toISOString()}\n`);
+    for (const result of results.filter(r => r)) {
+        if (!result)
+            continue;
+        const status = result.status === 'healthy' ? '✅ Healthy' : result.status === 'warning' ? '⚠️ Warning' : '❌ Breached';
+        const budgetBar = createBudgetBar(result.errorBudget.remaining);
+        console.log(`  ${result.name}`);
+        console.log(`  Status: ${status}`);
+        console.log(`  Target: ${result.target}% | Current: ${result.current.toFixed(2)}%`);
+        console.log(`  Error Budget: ${budgetBar} ${result.errorBudget.remaining.toFixed(2)}%`);
+        console.log(`  Burn Rate: ${result.errorBudget.burnRate.toFixed(2)}x`);
+        console.log('');
+    }
+});
+// Show error budget
+sloCommand
+    .command('budget')
+    .description('Show error budget status')
+    .option('--id <id>', 'SLO ID')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const config = createDefaultSLOConfig();
+    const tracker = new SLOTracker();
+    tracker.registerSLOs(config.slos);
+    const slos = options.id
+        ? ((slo => slo ? [slo] : [])(tracker.getSLO(options.id)))
+        : tracker.getAllSLOs();
+    if (options.json) {
+        console.log(JSON.stringify(slos.map(s => ({
+            id: s.id,
+            name: s.name,
+            errorBudget: s.errorBudget
+        })), null, 2));
+        return;
+    }
+    console.log('\n💰 Error Budget Status\n');
+    for (const slo of slos) {
+        if (!slo)
+            continue;
+        const budget = slo.errorBudget;
+        const budgetBar = createBudgetBar(budget.remainingBudget);
+        const status = budget.remainingBudget > 0 ? '✅' : '❌';
+        console.log(`  ${status} ${slo.name}`);
+        console.log(`      Initial Budget: ${budget.initialBudget}%`);
+        console.log(`      Remaining: ${budgetBar} ${budget.remainingBudget.toFixed(2)}%`);
+        console.log(`      Burned: ${(budget.initialBudget - budget.remainingBudget).toFixed(2)}%`);
+        console.log('');
+    }
+});
+// Create a new SLO
+sloCommand
+    .command('create')
+    .description('Create a new SLO')
+    .option('--name <name>', 'SLO name')
+    .option('--target <percentage>', 'Target percentage (0-100)', parseFloat)
+    .option('--window <duration>', 'Window duration (e.g., 7d, 30d)', '30d')
+    .option('--sli <ids...>', 'SLI IDs (comma-separated)')
+    .option('--tags <tags...>', 'Tags (comma-separated)')
+    .action(async (options) => {
+    if (!options.name) {
+        console.error('Error: --name is required');
+        process.exit(1);
+    }
+    if (options.target === undefined || options.target < 0 || options.target > 100) {
+        console.error('Error: --target must be between 0 and 100');
+        process.exit(1);
+    }
+    const windowMs = parseDuration(options.window);
+    const sliIds = options.sli ? options.sli.split(',') : [];
+    const tags = options.tags ? options.tags.split(',') : [];
+    const newSLO = {
+        id: `slo_${Date.now()}`,
+        name: options.name,
+        sliIds,
+        target: options.target,
+        windowMs,
+        errorBudget: {
+            initialBudget: 100 - options.target,
+            remainingBudget: 100 - options.target,
+            alertThresholds: { warning: 2, critical: 5 },
+            onExhaustion: 'alert_only'
+        },
+        status: 'unknown',
+        tags,
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+    };
+    console.log('\n✅ SLO Created\n');
+    console.log(`  ID: ${newSLO.id}`);
+    console.log(`  Name: ${newSLO.name}`);
+    console.log(`  Target: ${newSLO.target}%`);
+    console.log(`  Window: ${formatDuration(windowMs)}`);
+    console.log(`  SLIs: ${sliIds.join(', ') || 'None'}`);
+    console.log(`  Tags: ${tags.join(', ') || 'None'}`);
+    console.log('');
+});
+// Validate configuration
+sloCommand
+    .command('validate')
+    .description('Validate SLO configuration')
+    .option('--mode <mode>', 'Configuration mode: default, strict, relaxed', 'default')
+    .action(async (options) => {
+    let config;
+    switch (options.mode) {
+        case 'strict':
+            config = createStrictSLOConfig();
+            break;
+        case 'relaxed':
+            config = createRelaxedSLOConfig();
+            break;
+        default:
+            config = createDefaultSLOConfig();
+    }
+    console.log(`\n✅ SLO Configuration Validated (${options.mode} mode)\n`);
+    console.log(`  SLOs defined: ${config.slos.length}`);
+    console.log(`  SLIs defined: ${config.slis.length}`);
+    console.log(`  Default window: ${formatDuration(config.defaultWindowMs)}`);
+    console.log(`  On exhaustion: ${config.defaultOnExhaustion}`);
+    console.log('');
+    for (const slo of config.slos) {
+        console.log(`  • ${slo.name} (${slo.target}% target)`);
+    }
+    console.log('');
+});
+// Generate SLO report
+sloCommand
+    .command('report')
+    .description('Generate SLO report')
+    .option('--period <duration>', 'Report period (e.g., 7d, 30d)', '30d')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const config = createDefaultSLOConfig();
+    const tracker = new SLOTracker();
+    tracker.registerSLOs(config.slos);
+    tracker.registerSLIs(config.slis);
+    // Add demo measurements
+    for (const sli of config.slis) {
+        tracker.recordMeasurement({
+            sliId: sli.id,
+            timestamp: Date.now(),
+            value: 92 + Math.random() * 8,
+            total: 100,
+            good: 92 + Math.floor(Math.random() * 8),
+            bad: Math.floor(Math.random() * 8),
+            unit: sli.unit,
+            windowStart: Date.now() - parseDuration(options.period),
+            windowEnd: Date.now()
+        });
+    }
+    const report = tracker.generateReport({
+        start: Date.now() - parseDuration(options.period),
+        end: Date.now()
+    });
+    if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log('\n📊 SLO Report\n');
+    console.log(`Period: Last ${options.period}`);
+    console.log(`Generated: ${new Date(report.timestamp).toISOString()}`);
+    console.log(`Overall Status: ${formatStatus(report.status)}\n`);
+    console.log('Summary:');
+    console.log(`  Total SLOs: ${report.summary.total}`);
+    console.log(`  ✅ Healthy: ${report.summary.healthy}`);
+    console.log(`  ⚠️ Warning: ${report.summary.warning}`);
+    console.log(`  ❌ Breached: ${report.summary.breached}\n`);
+    if (report.slos.length > 0) {
+        console.log('SLO Details:\n');
+        for (const slo of report.slos) {
+            const status = slo.status === 'healthy' ? '✅' : slo.status === 'warning' ? '⚠️' : '❌';
+            console.log(`  ${status} ${slo.name}`);
+            console.log(`      Target: ${slo.target}% | Current: ${slo.current.toFixed(2)}%`);
+            console.log(`      Error Budget: ${slo.errorBudget.remaining.toFixed(2)}% remaining`);
+            console.log('');
+        }
+    }
+});
+// Helper functions
+function formatDuration(ms) {
+    const days = Math.floor(ms / (24 * 60 * 60 * 1000));
+    const hours = Math.floor((ms % (24 * 60 * 60 * 1000)) / (60 * 60 * 1000));
+    if (days > 0) {
+        return `${days} day${days > 1 ? 's' : ''}`;
+    }
+    if (hours > 0) {
+        return `${hours} hour${hours > 1 ? 's' : ''}`;
+    }
+    return `${ms}ms`;
+}
+function parseDuration(str) {
+    const match = str.match(/^(\d+)([dh])$/);
+    if (!match) {
+        return TimeWindows.MONTH; // Default
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+        case 'd':
+            return value * 24 * 60 * 60 * 1000;
+        case 'h':
+            return value * 60 * 60 * 1000;
+        default:
+            return TimeWindows.MONTH;
+    }
+}
+function createBudgetBar(remaining) {
+    const width = 20;
+    const filled = Math.round((remaining / 100) * width);
+    const bar = '█'.repeat(Math.max(0, filled)) + '░'.repeat(Math.max(0, width - filled));
+    const color = remaining > 50 ? '\x1b[32m' : remaining > 20 ? '\x1b[33m' : '\x1b[31m';
+    const reset = '\x1b[0m';
+    return `${color}[${bar}]${reset}`;
+}
+function formatStatus(status) {
+    switch (status) {
+        case 'healthy':
+            return '✅ Healthy';
+        case 'warning':
+            return '⚠️ Warning';
+        case 'breached':
+            return '❌ Breached';
+        default:
+            return '❓ Unknown';
+    }
+}
+export default sloCommand;

package/dist/core/adapters/playwright-native-api.d.ts

@@ -0,0 +1,183 @@
+/**
+ * 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 { ApiTarget, PackBudgets } from '../types/pack-v1.js';
+import { AuthCredentials } from '../auth/index.js';
+export interface NativeApiTestConfig {
+    target: ApiTarget;
+    budgets?: PackBudgets;
+    timeout?: number;
+    retries?: number;
+    auth?: AuthCredentials;
+    /**
+     * Basic auth credentials (username/password)
+     */
+    basicAuth?: {
+        username: string;
+        password: string;
+    };
+    /**
+     * Request body for POST/PUT/PATCH
+     */
+    body?: Record<string, unknown> | string;
+    /**
+     * Storage state to persist cookies/auth between requests
+     */
+    storageState?: Record<string, unknown> | string;
+    /**
+     * Cache configuration for HTTP responses
+     */
+    cache?: {
+        /** Enable caching (default: false) */
+        enabled?: boolean;
+        /** TTL in milliseconds (default: 300000 = 5 minutes) */
+        ttl?: number;
+        /** Maximum cache size in bytes (default: 10MB) */
+        maxSizeBytes?: number;
+        /** Maximum number of entries (default: 100) */
+        maxSize?: number;
+    };
+}
+export interface ApiTestResult {
+    endpoint: string;
+    method: string;
+    status: number;
+    responseTime: number;
+    success: boolean;
+    error?: string;
+    headers?: Record<string, string>;
+    body?: any;
+    attempts?: number;
+}
+export interface NativeApiSmokeResult {
+    success: boolean;
+    results: ApiTestResult[];
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        avgResponseTime: number;
+        totalAttempts: number;
+    };
+    junit?: string;
+    error?: string;
+}
+/**
+ * Playwright Native API Adapter
+ *
+ * Uses playwright.request.newContext() for direct HTTP requests
+ * without launching a browser.
+ */
+export declare class PlaywrightNativeApiAdapter {
+    private requestContext?;
+    private redactor;
+    private auth?;
+    private cache?;
+    constructor();
+    /**
+     * Set authentication credentials for requests
+     */
+    setAuth(credentials?: AuthCredentials): void;
+    /**
+     * Execute API smoke tests using Playwright's native API
+     */
+    runSmokeTests(config: NativeApiTestConfig): Promise<NativeApiSmokeResult>;
+    /**
+     * Setup Playwright APIRequestContext for HTTP requests
+     */
+    private setupRequestContext;
+    /**
+     * Execute single API test with retry logic using native API
+     */
+    private executeApiTest;
+    /**
+     * Parse test specification string
+     * Format: "GET /path -> 200" or "POST /api/users -> 201"
+     */
+    private parseTestSpec;
+    /**
+     * Check if error is retryable
+     */
+    private isRetryableError;
+    /**
+     * Calculate test summary
+     */
+    private calculateSummary;
+    /**
+     * Generate JUnit XML fragment
+     */
+    private generateJUnit;
+    /**
+     * Escape XML special characters
+     */
+    private escapeXml;
+    /**
+     * Cleanup request context
+     */
+    private cleanup;
+    /**
+     * Validate API target configuration
+     */
+    static validateConfig(target: ApiTarget): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Health check using native API
+     * Quick check if the API is accessible without running full tests
+     */
+    healthCheck(baseUrl: string, path?: string, timeout?: number): Promise<boolean>;
+    /**
+     * Get API info (useful for debugging)
+     * Returns version and capabilities
+     */
+    static getCapabilities(): {
+        adapter: string;
+        browserless: boolean;
+        features: string[];
+    };
+    /**
+     * Get cache statistics if cache is enabled
+     */
+    getCacheStats(): {
+        enabled: boolean;
+        stats?: {
+            hits: number;
+            misses: number;
+            additions: number;
+            evictions: number;
+            size: number;
+            sizeBytes: number;
+            hitRate: number;
+            avgEntrySize: number;
+        };
+    };
+    /**
+     * Clear the cache if enabled
+     */
+    clearCache(): void;
+}
+/**
+ * Factory function to create a native API adapter
+ */
+export declare function createPlaywrightNativeApiAdapter(): PlaywrightNativeApiAdapter;
+/**
+ * Error class for native API adapter
+ */
+export declare class PlaywrightNativeApiError extends Error {
+    code: string;
+    endpoint?: string;
+    method?: string;
+    constructor(message: string, endpoint?: string, method?: string);
+}