@testsmith/perfornium 0.1.0

package/dist/dsl/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testData = exports.faker = exports.load = exports.test = exports.LoadBuilder = exports.ScenarioBuilder = exports.TestBuilder = void 0;
+var test_builder_1 = require("./test-builder");
+Object.defineProperty(exports, "TestBuilder", { enumerable: true, get: function () { return test_builder_1.TestBuilder; } });
+Object.defineProperty(exports, "ScenarioBuilder", { enumerable: true, get: function () { return test_builder_1.ScenarioBuilder; } });
+Object.defineProperty(exports, "LoadBuilder", { enumerable: true, get: function () { return test_builder_1.LoadBuilder; } });
+Object.defineProperty(exports, "test", { enumerable: true, get: function () { return test_builder_1.test; } });
+Object.defineProperty(exports, "load", { enumerable: true, get: function () { return test_builder_1.load; } });
+Object.defineProperty(exports, "faker", { enumerable: true, get: function () { return test_builder_1.faker; } });
+Object.defineProperty(exports, "testData", { enumerable: true, get: function () { return test_builder_1.testData; } });

package/dist/dsl/test-builder.d.ts

@@ -0,0 +1,111 @@
+import type { TestConfiguration, Scenario, Step, LoadConfig, LoadPhase, GlobalConfig, OutputConfig } from '../config';
+import { getFaker } from '../utils/faker-manager';
+export interface ScenarioContext {
+    vu_id: number | string;
+    iteration: number;
+    variables: Record<string, any>;
+    page?: any;
+    request?: any;
+    [key: string]: any;
+}
+export declare class ScenarioBuilder {
+    private parent;
+    private scenario;
+    constructor(parent: TestBuilder, name: string, weight: number);
+    description(desc: string): this;
+    loop(count: number): this;
+    thinkTime(time: string | number): this;
+    variables(vars: Record<string, any>): this;
+    withCSV(file: string, options?: any): this;
+    beforeScenario(script: string | ((context: ScenarioContext) => Promise<void>)): this;
+    afterScenario(script: string | ((context: ScenarioContext) => Promise<void>)): this;
+    goto(url: string): this;
+    click(selector: string): this;
+    fill(selector: string, value: any): this;
+    select(selector: string, value: string): this;
+    expectVisible(selector: string, name?: string): this;
+    expectText(selector: string, text: string, name?: string): this;
+    expectNotVisible(selector: string, name?: string): this;
+    wait(duration: string | number): this;
+    get(path: string, options?: any): this;
+    post(path: string, body?: any, options?: any): this;
+    put(path: string, body?: any, options?: any): this;
+    patch(path: string, body?: any, options?: any): this;
+    delete(path: string, options?: any): this;
+    request(method: string, path: string, options?: any): this;
+    withBasicAuth(username: string, password: string): this;
+    withBearerToken(token: string): this;
+    withHeaders(headers: Record<string, string>): this;
+    withQuery(params: Record<string, string | number | boolean>): this;
+    withThinkTime(time: string | number): this;
+    extract(name: string, expression: string, type?: 'json_path' | 'regex'): this;
+    check(type: string, value: any, description?: string): this;
+    soap(operation: string, args: any, wsdl?: string): this;
+    step(name: string, script: string | ((context: ScenarioContext) => Promise<void>)): this;
+    addStep(step: Step): this;
+    done(): TestBuilder;
+    endScenario(): TestBuilder;
+}
+export declare class LoadBuilder {
+    private loadConfig;
+    name(name: string): this;
+    pattern(pattern: 'basic' | 'stepping' | 'arrivals'): this;
+    virtualUsers(count: number): this;
+    vus(count: number): this;
+    rampUp(duration: string): this;
+    duration(duration: string): this;
+    rate(requestsPerSecond: number): this;
+    steps(steps: any[]): this;
+    build(): LoadPhase;
+}
+export declare function test(name: string): TestBuilder;
+export declare function load(): LoadBuilder;
+/**
+ * Fluent DSL for building test configurations
+ *
+ * Usage:
+ *   const config = test('My Test')
+ *     .baseUrl('https://example.com')
+ *     .withBrowser('chromium', { headless: false })
+ *     .scenario('User Journey')
+ *       .goto('/')
+ *       .click('#login')
+ *       .fill('#username', 'test@example.com')
+ *       .expectVisible('#dashboard')
+ *       .done()
+ *     .withLoad({ pattern: 'basic', virtualUsers: 10 })
+ *     .build();
+ */
+export declare class TestBuilder {
+    private config;
+    constructor(name: string);
+    configuration(confis: GlobalConfig): this;
+    description(desc: string): this;
+    baseUrl(url: string): this;
+    timeout(ms: number): this;
+    thinkTime(time: string | number): this;
+    headers(headers: Record<string, string>): this;
+    withBrowser(type: 'chromium' | 'firefox' | 'webkit', options?: any): this;
+    withWSDL(url: string): this;
+    variables(vars: Record<string, any>): this;
+    scenario(name: string, weight?: number): ScenarioBuilder;
+    addScenario(scenario: Scenario): this;
+    withLoad(load: LoadConfig | LoadBuilder | LoadBuilder[]): this;
+    withLoadPhases(...phases: (LoadPhase | LoadBuilder)[]): this;
+    withOutput(type: string, options: Partial<OutputConfig>): this;
+    withJSONOutput(file: string): this;
+    withCSVOutput(file: string): this;
+    withReport(output?: string): this;
+    build(): TestConfiguration;
+    run(): Promise<void>;
+}
+export { getFaker as faker };
+export declare const testData: {
+    email: () => string;
+    password: () => string;
+    firstName: () => string;
+    lastName: () => string;
+    phone: () => string;
+    uuid: () => string;
+    randomInt: (min: number, max: number) => number;
+};

package/dist/dsl/test-builder.js

@@ -0,0 +1,514 @@
+"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.testData = exports.faker = exports.TestBuilder = exports.LoadBuilder = exports.ScenarioBuilder = void 0;
+exports.test = test;
+exports.load = load;
+const faker_manager_1 = require("../utils/faker-manager");
+Object.defineProperty(exports, "faker", { enumerable: true, get: function () { return faker_manager_1.getFaker; } });
+class ScenarioBuilder {
+    constructor(parent, name, weight) {
+        this.scenario = {
+            steps: []
+        };
+        this.parent = parent;
+        this.scenario.name = name;
+        this.scenario.weight = weight;
+    }
+    description(desc) {
+        this.scenario.description = desc;
+        return this;
+    }
+    loop(count) {
+        this.scenario.loop = count;
+        return this;
+    }
+    thinkTime(time) {
+        this.scenario.think_time = time;
+        return this;
+    }
+    variables(vars) {
+        this.scenario.variables = { ...this.scenario.variables, ...vars };
+        return this;
+    }
+    withCSV(file, options) {
+        this.scenario.csv_data = { file, ...options };
+        return this;
+    }
+    // Updated hook methods with context parameter
+    beforeScenario(script) {
+        const scriptStr = typeof script === 'function' ? script.toString() : script;
+        this.scenario.hooks = {
+            ...this.scenario.hooks,
+            beforeScenario: { script: scriptStr }
+        };
+        return this;
+    }
+    afterScenario(script) {
+        const scriptStr = typeof script === 'function' ? script.toString() : script;
+        this.scenario.hooks = {
+            ...this.scenario.hooks,
+            afterScenario: { script: scriptStr }
+        };
+        return this;
+    }
+    // Web step methods
+    goto(url) {
+        return this.addStep({
+            name: `Navigate to ${url}`,
+            type: 'web',
+            action: { command: 'goto', url }
+        });
+    }
+    click(selector) {
+        return this.addStep({
+            name: `Click ${selector}`,
+            type: 'web',
+            action: { command: 'click', selector }
+        });
+    }
+    fill(selector, value) {
+        const actualValue = typeof value === 'string' ? value : value.toString();
+        return this.addStep({
+            name: `Fill ${selector}`,
+            type: 'web',
+            action: { command: 'fill', selector, value: actualValue }
+        });
+    }
+    select(selector, value) {
+        return this.addStep({
+            name: `Select ${value} in ${selector}`,
+            type: 'web',
+            action: { command: 'select', selector, value }
+        });
+    }
+    // press(selector: string, key: string): this {
+    //     return this.addStep({
+    //         name: `Press ${key} on ${selector}`,
+    //         type: 'web',
+    //         action: { command: 'press', selector, key }
+    //     });
+    // }
+    expectVisible(selector, name) {
+        return this.addStep({
+            name: name || `Verify ${selector} is visible`,
+            type: 'web',
+            action: {
+                command: 'verify_visible',
+                selector,
+                ...(name && { name })
+            }
+        });
+    }
+    expectText(selector, text, name) {
+        return this.addStep({
+            name: name || `Verify ${selector} contains ${text}`,
+            type: 'web',
+            action: {
+                command: 'verify_text',
+                selector,
+                expected_text: text,
+                ...(name && { name })
+            }
+        });
+    }
+    expectNotVisible(selector, name) {
+        return this.addStep({
+            name: name || `Verify ${selector} is not visible`,
+            type: 'web',
+            action: {
+                command: 'verify_not_exists',
+                selector,
+                ...(name && { name })
+            }
+        });
+    }
+    wait(duration) {
+        const durationStr = typeof duration === 'number' ? `${duration}s` : duration;
+        return this.addStep({
+            name: `Wait ${durationStr}`,
+            type: 'wait',
+            duration: durationStr
+        });
+    }
+    // REST API step methods
+    get(path, options) {
+        return this.request('GET', path, options);
+    }
+    post(path, body, options) {
+        return this.request('POST', path, { ...options, json: body });
+    }
+    put(path, body, options) {
+        return this.request('PUT', path, { ...options, json: body });
+    }
+    patch(path, body, options) {
+        return this.request('PATCH', path, { ...options, json: body });
+    }
+    delete(path, options) {
+        return this.request('DELETE', path, options);
+    }
+    request(method, path, options) {
+        const step = {
+            name: options?.name || `${method} ${path}`,
+            type: 'rest',
+            method,
+            path
+        };
+        if (options?.headers)
+            step.headers = options.headers;
+        if (options?.json)
+            step.json = options.json;
+        if (options?.body)
+            step.body = options.body;
+        if (options?.xml)
+            step.xml = options.xml;
+        if (options?.form)
+            step.form = options.form;
+        if (options?.multipart)
+            step.multipart = options.multipart;
+        if (options?.query)
+            step.query = options.query;
+        if (options?.auth)
+            step.auth = options.auth;
+        if (options?.extract)
+            step.extract = options.extract;
+        if (options?.checks)
+            step.checks = options.checks;
+        if (options?.timeout)
+            step.timeout = options.timeout;
+        return this.addStep(step);
+    }
+    // Enhanced methods for different auth types
+    withBasicAuth(username, password) {
+        const lastStep = this.scenario.steps[this.scenario.steps.length - 1];
+        if (lastStep.type === 'rest') {
+            lastStep.auth = { type: 'basic', username, password };
+        }
+        return this;
+    }
+    withBearerToken(token) {
+        const lastStep = this.scenario.steps[this.scenario.steps.length - 1];
+        if (lastStep.type === 'rest') {
+            lastStep.auth = { type: 'bearer', token };
+        }
+        return this;
+    }
+    withHeaders(headers) {
+        const lastStep = this.scenario.steps[this.scenario.steps.length - 1];
+        if (lastStep.type === 'rest') {
+            lastStep.headers = { ...lastStep.headers, ...headers };
+        }
+        return this;
+    }
+    withQuery(params) {
+        const lastStep = this.scenario.steps[this.scenario.steps.length - 1];
+        if (lastStep.type === 'rest') {
+            lastStep.query = params;
+        }
+        return this;
+    }
+    // Add think time to the last step
+    withThinkTime(time) {
+        const lastStep = this.scenario.steps[this.scenario.steps.length - 1];
+        lastStep.think_time = time;
+        return this;
+    }
+    extract(name, expression, type = 'json_path') {
+        const lastStep = this.scenario.steps[this.scenario.steps.length - 1];
+        if (!lastStep.extract)
+            lastStep.extract = [];
+        lastStep.extract.push({ name, expression, type });
+        return this;
+    }
+    check(type, value, description) {
+        const lastStep = this.scenario.steps[this.scenario.steps.length - 1];
+        if (!lastStep.checks)
+            lastStep.checks = [];
+        lastStep.checks.push({ type, value, description });
+        return this;
+    }
+    // SOAP step method
+    soap(operation, args, wsdl) {
+        return this.addStep({
+            name: `SOAP ${operation}`,
+            type: 'soap',
+            operation,
+            args,
+            ...(wsdl && { wsdl })
+        });
+    }
+    // Custom step method
+    // Updated custom step method with context
+    step(name, script) {
+        const scriptStr = typeof script === 'function' ?
+            `(${script.toString()})(context)` : script;
+        return this.addStep({
+            name,
+            type: 'custom',
+            script: scriptStr
+        });
+    }
+    // Add a raw step
+    addStep(step) {
+        this.scenario.steps = [...(this.scenario.steps || []), step];
+        return this;
+    }
+    // Finish scenario and return to parent
+    done() {
+        this.parent.addScenario(this.scenario);
+        return this.parent;
+    }
+    // Alias for done()
+    endScenario() {
+        return this.done();
+    }
+}
+exports.ScenarioBuilder = ScenarioBuilder;
+class LoadBuilder {
+    constructor() {
+        this.loadConfig = {};
+    }
+    name(name) {
+        this.loadConfig.name = name;
+        return this;
+    }
+    pattern(pattern) {
+        this.loadConfig.pattern = pattern;
+        return this;
+    }
+    virtualUsers(count) {
+        this.loadConfig.virtual_users = count;
+        return this;
+    }
+    vus(count) {
+        this.loadConfig.vus = count;
+        return this;
+    }
+    rampUp(duration) {
+        this.loadConfig.ramp_up = duration;
+        return this;
+    }
+    duration(duration) {
+        this.loadConfig.duration = duration;
+        return this;
+    }
+    rate(requestsPerSecond) {
+        this.loadConfig.rate = requestsPerSecond;
+        return this;
+    }
+    steps(steps) {
+        this.loadConfig.steps = steps;
+        return this;
+    }
+    build() {
+        if (!this.loadConfig.pattern) {
+            this.loadConfig.pattern = 'basic';
+        }
+        if (!this.loadConfig.duration) {
+            this.loadConfig.duration = '1m'; // Default duration
+        }
+        return this.loadConfig;
+    }
+}
+exports.LoadBuilder = LoadBuilder;
+// Factory functions for convenience
+function test(name) {
+    return new TestBuilder(name);
+}
+function load() {
+    return new LoadBuilder();
+}
+/**
+ * Fluent DSL for building test configurations
+ *
+ * Usage:
+ *   const config = test('My Test')
+ *     .baseUrl('https://example.com')
+ *     .withBrowser('chromium', { headless: false })
+ *     .scenario('User Journey')
+ *       .goto('/')
+ *       .click('#login')
+ *       .fill('#username', 'test@example.com')
+ *       .expectVisible('#dashboard')
+ *       .done()
+ *     .withLoad({ pattern: 'basic', virtualUsers: 10 })
+ *     .build();
+ */
+class TestBuilder {
+    constructor(name) {
+        this.config = {
+            scenarios: [],
+            outputs: [],
+            global: {}
+        };
+        this.config.name = name;
+    }
+    configuration(confis) {
+        this.config = confis;
+        return this;
+    }
+    description(desc) {
+        this.config.description = desc;
+        return this;
+    }
+    // Global configuration methods
+    baseUrl(url) {
+        this.config.global = { ...this.config.global, base_url: url };
+        return this;
+    }
+    timeout(ms) {
+        this.config.global = { ...this.config.global, timeout: ms };
+        return this;
+    }
+    thinkTime(time) {
+        this.config.global = { ...this.config.global, think_time: time };
+        return this;
+    }
+    headers(headers) {
+        this.config.global = {
+            ...this.config.global,
+            headers: { ...(this.config.global?.headers || {}), ...headers }
+        };
+        return this;
+    }
+    withBrowser(type, options) {
+        this.config.global = {
+            ...this.config.global,
+            browser: {
+                type,
+                ...options
+            }
+        };
+        return this;
+    }
+    withWSDL(url) {
+        this.config.global = { ...this.config.global, wsdl_url: url };
+        return this;
+    }
+    variables(vars) {
+        if (!this.config.global) {
+            this.config.global = {};
+        }
+        this.config.global = {
+            ...this.config.global,
+            variables: { ...(this.config.global.variables || {}), ...vars }
+        };
+        return this;
+    }
+    // Create a new scenario
+    scenario(name, weight = 100) {
+        return new ScenarioBuilder(this, name, weight);
+    }
+    // Add a complete scenario
+    addScenario(scenario) {
+        this.config.scenarios = [...(this.config.scenarios || []), scenario];
+        return this;
+    }
+    // Load configuration - supports single phase or array of phases
+    withLoad(load) {
+        if (Array.isArray(load)) {
+            // Array of LoadBuilders - build each one
+            this.config.load = load.map(lb => lb instanceof LoadBuilder ? lb.build() : lb);
+        }
+        else if (load instanceof LoadBuilder) {
+            this.config.load = load.build();
+        }
+        else {
+            this.config.load = load;
+        }
+        return this;
+    }
+    // Add multiple load phases (sequential execution)
+    withLoadPhases(...phases) {
+        this.config.load = phases.map(phase => phase instanceof LoadBuilder ? phase.build() : phase);
+        return this;
+    }
+    // Output configuration
+    withOutput(type, options) {
+        this.config.outputs = [
+            ...(this.config.outputs || []),
+            { type, ...options }
+        ];
+        return this;
+    }
+    withJSONOutput(file) {
+        return this.withOutput('json', { file });
+    }
+    withCSVOutput(file) {
+        return this.withOutput('csv', { file });
+    }
+    // Report configuration
+    withReport(output = 'report.html') {
+        this.config.report = {
+            generate: true,
+            output
+        };
+        return this;
+    }
+    // Build the final configuration
+    build() {
+        if (!this.config.name)
+            throw new Error('Test name is required');
+        if (!this.config.load) {
+            // Default load configuration
+            this.config.load = {
+                pattern: 'basic',
+                virtual_users: 1,
+                ramp_up: '10s',
+                duration: '1m'
+            };
+        }
+        if (!this.config.scenarios || this.config.scenarios.length === 0) {
+            throw new Error('At least one scenario is required');
+        }
+        return this.config;
+    }
+    // Run the test directly
+    async run() {
+        const { TestRunner } = await Promise.resolve().then(() => __importStar(require('../core/test-runner')));
+        const runner = new TestRunner(this.build());
+        await runner.run();
+    }
+}
+exports.TestBuilder = TestBuilder;
+exports.testData = {
+    email: () => (0, faker_manager_1.getFaker)().internet.email(),
+    password: () => (0, faker_manager_1.getFaker)().internet.password(),
+    firstName: () => (0, faker_manager_1.getFaker)().person.firstName(),
+    lastName: () => (0, faker_manager_1.getFaker)().person.lastName(),
+    phone: () => (0, faker_manager_1.getFaker)().phone.number(),
+    uuid: () => (0, faker_manager_1.getFaker)().string.uuid(),
+    randomInt: (min, max) => (0, faker_manager_1.getFaker)().number.int({ min, max })
+};

package/dist/importers/har-importer.d.ts

@@ -0,0 +1,17 @@
+import { ImportableEndpoint } from "../config/types/import-types";
+export declare class HARImporter {
+    private har;
+    constructor(harContent: any);
+    extractEndpoints(): ImportableEndpoint[];
+    generateScenarios(selectedEndpoints: ImportableEndpoint[]): any[];
+    private isAPIRequest;
+    private extractPath;
+    private extractParametersFromHAR;
+    private extractRequestBodyFromHAR;
+    private extractContentType;
+    private deduplicateEndpoints;
+    private extractHeadersFromEndpoint;
+    private parseRequestBody;
+    private generateHARExtractions;
+    private hasField;
+}