@testsmith/perfornium 0.1.0

package/dist/recorder/scenario-recorder.js

@@ -0,0 +1,296 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScenarioRecorder = void 0;
+const events_1 = require("events");
+const fs_1 = require("fs");
+const yaml = __importStar(require("yaml"));
+const logger_1 = require("../utils/logger");
+class ScenarioRecorder extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.recording = false;
+        this.currentScenario = null;
+        this.recordedRequests = [];
+        this.startTime = 0;
+        this.extractionRules = new Map();
+    }
+    startRecording(scenarioName, description) {
+        if (this.recording) {
+            throw new Error('Recording already in progress');
+        }
+        this.recording = true;
+        this.startTime = Date.now();
+        this.recordedRequests = [];
+        this.currentScenario = {
+            name: scenarioName,
+            description,
+            steps: []
+        };
+        logger_1.logger.info(`🔴 Started recording scenario: ${scenarioName}`);
+        this.emit('recording:started', scenarioName);
+    }
+    recordRequest(request) {
+        if (!this.recording) {
+            return;
+        }
+        request.timestamp = Date.now() - this.startTime;
+        this.recordedRequests.push(request);
+        this.detectVariables(request);
+        this.detectExtractions(request);
+        this.emit('request:recorded', request);
+        logger_1.logger.debug(`📝 Recorded ${request.method} ${request.path}`);
+    }
+    detectVariables(request) {
+        if (!this.currentScenario)
+            return;
+        const variables = {};
+        const urlPattern = /\{([^}]+)\}/g;
+        let match;
+        while ((match = urlPattern.exec(request.path)) !== null) {
+            variables[match[1]] = `{{${match[1]}}}`;
+        }
+        if (request.headers?.['Authorization']) {
+            variables['auth_token'] = request.headers['Authorization'];
+        }
+        if (Object.keys(variables).length > 0) {
+            this.currentScenario.variables = {
+                ...this.currentScenario.variables,
+                ...variables
+            };
+        }
+    }
+    detectExtractions(request) {
+        if (!request.response?.data || !this.currentScenario)
+            return;
+        const extractions = [];
+        const commonFields = [
+            'id', 'token', 'access_token', 'refresh_token',
+            'session_id', 'sessionId', 'user_id', 'userId'
+        ];
+        if (typeof request.response.data === 'object') {
+            for (const field of commonFields) {
+                if (this.hasNestedField(request.response.data, field)) {
+                    const path = this.findJsonPath(request.response.data, field);
+                    if (path) {
+                        extractions.push({
+                            from: request.path,
+                            name: field,
+                            expression: path,
+                            type: 'json_path'
+                        });
+                    }
+                }
+            }
+        }
+        if (request.response.headers?.['set-cookie']) {
+            extractions.push({
+                from: request.path,
+                name: 'session_cookie',
+                expression: 'set-cookie',
+                type: 'cookie'
+            });
+        }
+        if (extractions.length > 0) {
+            this.currentScenario.extractions = [
+                ...(this.currentScenario.extractions || []),
+                ...extractions
+            ];
+        }
+    }
+    hasNestedField(obj, field) {
+        if (!obj || typeof obj !== 'object')
+            return false;
+        if (field in obj)
+            return true;
+        for (const value of Object.values(obj)) {
+            if (this.hasNestedField(value, field))
+                return true;
+        }
+        return false;
+    }
+    findJsonPath(obj, field, path = '$') {
+        if (!obj || typeof obj !== 'object')
+            return null;
+        if (field in obj) {
+            return `${path}.${field}`;
+        }
+        for (const [key, value] of Object.entries(obj)) {
+            const result = this.findJsonPath(value, field, `${path}.${key}`);
+            if (result)
+                return result;
+        }
+        return null;
+    }
+    stopRecording() {
+        if (!this.recording || !this.currentScenario) {
+            return null;
+        }
+        this.recording = false;
+        this.currentScenario.steps = this.optimizeSteps(this.recordedRequests);
+        const scenario = this.currentScenario;
+        this.currentScenario = null;
+        logger_1.logger.info(`⏹️ Stopped recording. Captured ${scenario.steps.length} steps`);
+        this.emit('recording:stopped', scenario);
+        return scenario;
+    }
+    optimizeSteps(requests) {
+        const optimized = [];
+        const seenUrls = new Set();
+        for (const request of requests) {
+            const urlKey = `${request.method}_${request.path}`;
+            if (!seenUrls.has(urlKey) || this.isImportantRequest(request)) {
+                optimized.push(this.cleanRequest(request));
+                seenUrls.add(urlKey);
+            }
+        }
+        return optimized;
+    }
+    isImportantRequest(request) {
+        const importantMethods = ['POST', 'PUT', 'PATCH', 'DELETE'];
+        return importantMethods.includes(request.method);
+    }
+    cleanRequest(request) {
+        const cleaned = {
+            timestamp: request.timestamp,
+            method: request.method,
+            url: request.url,
+            path: request.path
+        };
+        const skipHeaders = [
+            'user-agent', 'accept-encoding', 'connection',
+            'content-length', 'host', 'cache-control'
+        ];
+        if (request.headers) {
+            cleaned.headers = Object.fromEntries(Object.entries(request.headers)
+                .filter(([key]) => !skipHeaders.includes(key.toLowerCase())));
+        }
+        if (request.params && Object.keys(request.params).length > 0) {
+            cleaned.params = request.params;
+        }
+        if (request.body) {
+            cleaned.body = request.body;
+        }
+        if (request.response) {
+            cleaned.response = {
+                status: request.response.status,
+                statusText: request.response.statusText,
+                duration: request.response.duration
+            };
+        }
+        return cleaned;
+    }
+    exportScenario(scenario, format) {
+        switch (format) {
+            case 'yaml':
+                return this.exportAsYAML(scenario);
+            case 'typescript':
+                return this.exportAsTypeScript(scenario);
+            case 'json':
+                return JSON.stringify(this.convertToTestConfig(scenario), null, 2);
+            default:
+                throw new Error(`Unsupported format: ${format}`);
+        }
+    }
+    exportAsYAML(scenario) {
+        const config = this.convertToTestConfig(scenario);
+        return yaml.stringify(config);
+    }
+    exportAsTypeScript(scenario) {
+        const config = this.convertToTestConfig(scenario);
+        return `import { TestConfiguration } from 'perfornium';
+
+export const config: TestConfiguration = ${JSON.stringify(config, null, 2)
+            .replace(/"([^"]+)":/g, '$1:')
+            .replace(/"/g, "'")};
+
+export default config;`;
+    }
+    convertToTestConfig(scenario) {
+        const steps = scenario.steps.map(step => ({
+            name: `${step.method} ${step.path}`,
+            type: 'rest',
+            method: step.method,
+            path: step.path,
+            ...(step.headers && { headers: step.headers }),
+            ...(step.params && { params: step.params }),
+            ...(step.body && {
+                [typeof step.body === 'object' ? 'json' : 'body']: step.body
+            }),
+            ...(scenario.extractions && {
+                extract: scenario.extractions
+                    .filter(e => e.from === step.path)
+                    .map(e => ({
+                    name: e.name,
+                    type: e.type,
+                    expression: e.expression
+                }))
+            })
+        }));
+        return {
+            name: scenario.name,
+            description: scenario.description,
+            ...(scenario.baseURL && {
+                global: {
+                    base_url: scenario.baseURL
+                }
+            }),
+            scenarios: [{
+                    name: scenario.name,
+                    ...(scenario.variables && { variables: scenario.variables }),
+                    steps
+                }],
+            load: {
+                pattern: 'basic',
+                vus: 1,
+                duration: '1m'
+            }
+        };
+    }
+    saveToFile(scenario, filename, format) {
+        const content = this.exportScenario(scenario, format);
+        const extension = format === 'typescript' ? 'ts' : format;
+        const fullPath = filename.endsWith(`.${extension}`) ? filename : `${filename}.${extension}`;
+        (0, fs_1.writeFileSync)(fullPath, content);
+        logger_1.logger.success(`💾 Saved scenario to ${fullPath}`);
+    }
+    isRecording() {
+        return this.recording;
+    }
+    getRecordedRequestsCount() {
+        return this.recordedRequests.length;
+    }
+}
+exports.ScenarioRecorder = ScenarioRecorder;

package/dist/reporting/constants.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Reporting and metrics constants
+ * Centralized configuration for all magic numbers
+ */
+export declare const TIME_BUCKETS: {
+    readonly FINE: 1000;
+    readonly MEDIUM: 5000;
+    readonly COARSE: 10000;
+};
+export declare const PERCENTILES: {
+    STANDARD: number[];
+    EXTENDED: number[];
+};
+export declare const APDEX_DEFAULTS: {
+    readonly SATISFIED_THRESHOLD: 500;
+    readonly TOLERATING_MULTIPLIER: 4;
+};
+export declare const SLA_DEFAULTS: {
+    SUCCESS_RATE: number;
+    AVG_RESPONSE_TIME: number;
+    P95_RESPONSE_TIME: number;
+    P99_RESPONSE_TIME: number;
+    MIN_REQUESTS_PER_SECOND: number;
+};
+export declare const WEB_VITALS_THRESHOLDS: {
+    readonly LCP: {
+        readonly good: 2500;
+        readonly poor: 4000;
+    };
+    readonly FID: {
+        readonly good: 100;
+        readonly poor: 300;
+    };
+    readonly CLS: {
+        readonly good: 0.1;
+        readonly poor: 0.25;
+    };
+    readonly FCP: {
+        readonly good: 1800;
+        readonly poor: 3000;
+    };
+    readonly TTFB: {
+        readonly good: 800;
+        readonly poor: 1800;
+    };
+    readonly TTI: {
+        readonly good: 3800;
+        readonly poor: 7300;
+    };
+    readonly TBT: {
+        readonly good: 200;
+        readonly poor: 600;
+    };
+    readonly SPEED_INDEX: {
+        readonly good: 3400;
+        readonly poor: 5800;
+    };
+    readonly INP: {
+        readonly good: 200;
+        readonly poor: 500;
+    };
+};
+export declare const OUTLIER_DETECTION: {
+    readonly IQR_MULTIPLIER: 1.5;
+    readonly IQR_EXTREME_MULTIPLIER: 3;
+    readonly Z_SCORE_THRESHOLD: 3;
+};
+export declare const CONFIDENCE_INTERVALS: {
+    readonly LEVELS: readonly [0.9, 0.95, 0.99];
+    readonly DEFAULT_LEVEL: 0.95;
+};
+export declare const HEATMAP: {
+    readonly TIME_BUCKETS: 50;
+    readonly RESPONSE_TIME_BUCKETS: 20;
+};
+export declare const REPORT_SETTINGS: {
+    readonly MAX_RAW_DATA_ROWS: 1000;
+    readonly CHART_DATA_POINTS_LIMIT: 500;
+    readonly BATCH_SIZE: 10;
+    readonly FLUSH_INTERVAL: 5000;
+};
+export declare const STATUS_THRESHOLDS: {
+    readonly SUCCESS_RATE_GOOD: 99;
+    readonly SUCCESS_RATE_WARNING: 95;
+};
+export declare const RESPONSE_TIME_FIELD: "response_time";
+export declare const DURATION_FIELD: "duration";
+/**
+ * Get response time from a result, preferring response_time over duration
+ */
+export declare function getResponseTime(result: {
+    response_time?: number;
+    duration?: number;
+}): number;

package/dist/reporting/constants.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Reporting and metrics constants
+ * Centralized configuration for all magic numbers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DURATION_FIELD = exports.RESPONSE_TIME_FIELD = exports.STATUS_THRESHOLDS = exports.REPORT_SETTINGS = exports.HEATMAP = exports.CONFIDENCE_INTERVALS = exports.OUTLIER_DETECTION = exports.WEB_VITALS_THRESHOLDS = exports.SLA_DEFAULTS = exports.APDEX_DEFAULTS = exports.PERCENTILES = exports.TIME_BUCKETS = void 0;
+exports.getResponseTime = getResponseTime;
+// Time bucket sizes (milliseconds)
+exports.TIME_BUCKETS = {
+    FINE: 1000, // 1 second - for detailed analysis
+    MEDIUM: 5000, // 5 seconds - for timeline charts
+    COARSE: 10000, // 10 seconds - for trend analysis
+};
+// Standard percentiles to calculate
+exports.PERCENTILES = {
+    STANDARD: [50, 90, 95, 99],
+    EXTENDED: [50, 90, 95, 99, 99.9, 99.99],
+};
+// Apdex score thresholds (in milliseconds)
+exports.APDEX_DEFAULTS = {
+    SATISFIED_THRESHOLD: 500, // Requests under this are "satisfied"
+    TOLERATING_MULTIPLIER: 4, // Requests under threshold * 4 are "tolerating"
+};
+// SLA default thresholds
+exports.SLA_DEFAULTS = {
+    SUCCESS_RATE: 95.0, // Minimum success rate percentage
+    AVG_RESPONSE_TIME: 2000, // Maximum average response time (ms)
+    P95_RESPONSE_TIME: 5000, // Maximum P95 response time (ms)
+    P99_RESPONSE_TIME: 10000, // Maximum P99 response time (ms)
+    MIN_REQUESTS_PER_SECOND: 0.1, // Minimum throughput (very low default - user should configure)
+};
+// Web Vitals thresholds (from Google)
+exports.WEB_VITALS_THRESHOLDS = {
+    LCP: { good: 2500, poor: 4000 }, // Largest Contentful Paint (ms)
+    FID: { good: 100, poor: 300 }, // First Input Delay (ms)
+    CLS: { good: 0.1, poor: 0.25 }, // Cumulative Layout Shift (score)
+    FCP: { good: 1800, poor: 3000 }, // First Contentful Paint (ms)
+    TTFB: { good: 800, poor: 1800 }, // Time to First Byte (ms)
+    TTI: { good: 3800, poor: 7300 }, // Time to Interactive (ms)
+    TBT: { good: 200, poor: 600 }, // Total Blocking Time (ms)
+    SPEED_INDEX: { good: 3400, poor: 5800 }, // Speed Index (ms)
+    INP: { good: 200, poor: 500 }, // Interaction to Next Paint (ms)
+};
+// Outlier detection thresholds
+exports.OUTLIER_DETECTION = {
+    IQR_MULTIPLIER: 1.5, // Standard IQR multiplier for mild outliers
+    IQR_EXTREME_MULTIPLIER: 3.0, // IQR multiplier for extreme outliers
+    Z_SCORE_THRESHOLD: 3.0, // Z-score threshold for outliers
+};
+// Confidence interval settings
+exports.CONFIDENCE_INTERVALS = {
+    LEVELS: [0.90, 0.95, 0.99], // 90%, 95%, 99% confidence levels
+    DEFAULT_LEVEL: 0.95, // Default confidence level
+};
+// Heatmap settings
+exports.HEATMAP = {
+    TIME_BUCKETS: 50, // Number of time buckets
+    RESPONSE_TIME_BUCKETS: 20, // Number of response time buckets
+};
+// Report generation settings
+exports.REPORT_SETTINGS = {
+    MAX_RAW_DATA_ROWS: 1000, // Maximum raw data rows to include
+    CHART_DATA_POINTS_LIMIT: 500, // Maximum data points per chart
+    BATCH_SIZE: 10, // Default batch size for metrics collection
+    FLUSH_INTERVAL: 5000, // Default flush interval (ms)
+};
+// Status thresholds for visual indicators
+exports.STATUS_THRESHOLDS = {
+    SUCCESS_RATE_GOOD: 99, // Green status
+    SUCCESS_RATE_WARNING: 95, // Yellow status
+    // Below WARNING is red/error status
+};
+// Response time field to use (standardized)
+exports.RESPONSE_TIME_FIELD = 'response_time';
+exports.DURATION_FIELD = 'duration';
+/**
+ * Get response time from a result, preferring response_time over duration
+ */
+function getResponseTime(result) {
+    return result.response_time ?? result.duration ?? 0;
+}

package/dist/reporting/enhanced-html-generator.d.ts

@@ -0,0 +1,55 @@
+import { TestResult, MetricsSummary } from '../metrics/types';
+export interface HTMLReportConfig {
+    title?: string;
+    description?: string;
+    includeCharts?: boolean;
+    includeTimeline?: boolean;
+    includeErrorDetails?: boolean;
+    includeResponseTimes?: boolean;
+    templatePath?: string;
+    assetsInline?: boolean;
+    darkMode?: boolean;
+    sla?: {
+        successRate?: number;
+        avgResponseTime?: number;
+        p95ResponseTime?: number;
+        p99ResponseTime?: number;
+        minThroughput?: number;
+    };
+    apdexThreshold?: number;
+}
+export interface HTMLReportData {
+    testName: string;
+    summary: MetricsSummary;
+    results?: TestResult[];
+    config?: any;
+    metadata?: {
+        generated_at: string;
+        generated_by: string;
+        test_duration: string;
+        [key: string]: any;
+    };
+}
+export declare class EnhancedHTMLReportGenerator {
+    private config;
+    private templateCache;
+    private readonly DEFAULT_CONFIG;
+    constructor(config?: HTMLReportConfig);
+    private setupHandlebarsHelpers;
+    generate(data: HTMLReportData, filePath: string): Promise<string>;
+    private prepareReportData;
+    private prepareChartData;
+    private prepareTimelineData;
+    private prepareErrorAnalysis;
+    private prepareResponseTimeAnalysis;
+    private createResponseTimeHistogram;
+    private prepareWebVitalsCharts;
+    private getMetricColor;
+    private analyzeByPage;
+    private calculateAverageScore;
+    private generateColors;
+    private loadTemplate;
+    private getDefaultTemplatePath;
+    private formatDuration;
+    private getDefaultTemplate;
+}