@testsmith/perfornium 0.1.0

package/dist/importers/har-importer.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARImporter = void 0;
+class HARImporter {
+    constructor(harContent) {
+        this.har = harContent;
+    }
+    extractEndpoints() {
+        const endpoints = [];
+        const entries = this.har.log?.entries || [];
+        entries.forEach((entry, index) => {
+            const request = entry.request;
+            const response = entry.response;
+            // Skip non-API requests (images, CSS, JS, etc.)
+            if (!this.isAPIRequest(request))
+                return;
+            endpoints.push({
+                id: `har_${index}`,
+                name: `${request.method} ${this.extractPath(request.url)}`,
+                method: request.method,
+                path: this.extractPath(request.url),
+                description: `Captured from HAR: ${request.url}`,
+                parameters: this.extractParametersFromHAR(request),
+                requestBody: this.extractRequestBodyFromHAR(request),
+                responses: [{
+                        statusCode: response.status,
+                        contentType: this.extractContentType(response),
+                        schema: null,
+                        example: response.content?.text
+                    }],
+                selected: false
+            });
+        });
+        return this.deduplicateEndpoints(endpoints);
+    }
+    generateScenarios(selectedEndpoints) {
+        return selectedEndpoints.map(endpoint => ({
+            name: `test_${endpoint.path.replace(/[\/\{\}]/g, '_')}`,
+            steps: [{
+                    name: endpoint.name,
+                    method: endpoint.method,
+                    path: endpoint.path,
+                    headers: this.extractHeadersFromEndpoint(endpoint),
+                    json: this.parseRequestBody(endpoint.requestBody),
+                    extract: this.generateHARExtractions(endpoint)
+                }]
+        }));
+    }
+    isAPIRequest(request) {
+        const url = request.url.toLowerCase();
+        const method = request.method.toUpperCase();
+        // Skip static resources
+        const staticExtensions = ['.js', '.css', '.png', '.jpg', '.gif', '.ico', '.svg', '.woff', '.ttf'];
+        if (staticExtensions.some(ext => url.includes(ext)))
+            return false;
+        // Include API-like requests
+        const apiIndicators = ['/api/', '/v1/', '/v2/', '/graphql', '.json', '.xml'];
+        const hasAPIIndicator = apiIndicators.some(indicator => url.includes(indicator));
+        // Include non-GET requests to any endpoint
+        const isNonGetRequest = method !== 'GET';
+        return hasAPIIndicator || isNonGetRequest;
+    }
+    extractPath(url) {
+        try {
+            const urlObj = new URL(url);
+            return urlObj.pathname + urlObj.search;
+        }
+        catch {
+            return url;
+        }
+    }
+    extractParametersFromHAR(request) {
+        const params = [];
+        // Query parameters
+        request.queryString?.forEach((param) => {
+            params.push({
+                name: param.name,
+                in: 'query',
+                required: false,
+                type: 'string',
+                example: param.value
+            });
+        });
+        // Header parameters (excluding standard headers)
+        const skipHeaders = ['host', 'user-agent', 'accept', 'accept-encoding', 'connection'];
+        request.headers?.forEach((header) => {
+            if (!skipHeaders.includes(header.name.toLowerCase())) {
+                params.push({
+                    name: header.name,
+                    in: 'header',
+                    required: false,
+                    type: 'string',
+                    example: header.value
+                });
+            }
+        });
+        return params;
+    }
+    extractRequestBodyFromHAR(request) {
+        const postData = request.postData;
+        if (!postData)
+            return undefined;
+        return {
+            contentType: postData.mimeType || 'application/json',
+            schema: null,
+            example: postData.text,
+            required: true
+        };
+    }
+    extractContentType(response) {
+        const contentTypeHeader = response.headers?.find((h) => h.name.toLowerCase() === 'content-type');
+        return contentTypeHeader?.value || 'application/json';
+    }
+    deduplicateEndpoints(endpoints) {
+        const seen = new Set();
+        return endpoints.filter(endpoint => {
+            const key = `${endpoint.method}_${endpoint.path}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
+    extractHeadersFromEndpoint(endpoint) {
+        const headers = {};
+        endpoint.parameters?.forEach(param => {
+            if (param.in === 'header') {
+                headers[param.name] = param.example || `{{${param.name}}}`;
+            }
+        });
+        return headers;
+    }
+    parseRequestBody(requestBody) {
+        if (!requestBody?.example)
+            return undefined;
+        try {
+            return JSON.parse(requestBody.example);
+        }
+        catch {
+            return requestBody.example;
+        }
+    }
+    generateHARExtractions(endpoint) {
+        // Generate common extractions based on response patterns
+        const extractions = [];
+        endpoint.responses?.forEach(response => {
+            if (response.example) {
+                try {
+                    const parsed = JSON.parse(response.example);
+                    const commonFields = ['id', 'token', 'access_token', 'sessionId'];
+                    commonFields.forEach(field => {
+                        if (this.hasField(parsed, field)) {
+                            extractions.push({
+                                name: field,
+                                type: 'json_path',
+                                expression: `$.${field}`
+                            });
+                        }
+                    });
+                }
+                catch {
+                    // Not JSON, skip extraction generation
+                }
+            }
+        });
+        return extractions;
+    }
+    hasField(obj, field) {
+        return obj && typeof obj === 'object' && field in obj;
+    }
+}
+exports.HARImporter = HARImporter;

package/dist/importers/open-api-importer.d.ts

@@ -0,0 +1,23 @@
+import { ImportableEndpoint } from "../config/types/import-types";
+export declare class OpenAPIImporter {
+    private spec;
+    constructor(spec: any);
+    /**
+     * Parse OpenAPI spec and extract all available endpoints
+     */
+    extractEndpoints(): ImportableEndpoint[];
+    /**
+     * Generate test scenarios from selected endpoints
+     */
+    generateScenarios(selectedEndpoints: ImportableEndpoint[]): any[];
+    private extractParameters;
+    private parseParameters;
+    private extractRequestBody;
+    private extractResponses;
+    private generateHeaders;
+    private generateRequestBody;
+    private generateExtractions;
+    private generateFromSchema;
+    private generateValueFromSchema;
+    private schemaHasProperty;
+}

package/dist/importers/open-api-importer.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPIImporter = void 0;
+class OpenAPIImporter {
+    constructor(spec) {
+        this.spec = spec;
+    }
+    /**
+     * Parse OpenAPI spec and extract all available endpoints
+     */
+    extractEndpoints() {
+        const endpoints = [];
+        const paths = this.spec.paths || {};
+        for (const [path, pathItem] of Object.entries(paths)) {
+            const methods = ['get', 'post', 'put', 'patch', 'delete', 'options', 'head'];
+            for (const method of methods) {
+                const operation = pathItem[method];
+                if (!operation)
+                    continue;
+                endpoints.push({
+                    id: `${method.toUpperCase()}_${path}`,
+                    name: operation.summary || operation.operationId || `${method.toUpperCase()} ${path}`,
+                    method: method.toUpperCase(),
+                    path: path,
+                    description: operation.description,
+                    parameters: this.extractParameters(operation, pathItem),
+                    requestBody: this.extractRequestBody(operation),
+                    responses: this.extractResponses(operation),
+                    tags: operation.tags || [],
+                    selected: false
+                });
+            }
+        }
+        return endpoints;
+    }
+    /**
+     * Generate test scenarios from selected endpoints
+     */
+    generateScenarios(selectedEndpoints) {
+        return selectedEndpoints.map(endpoint => ({
+            name: `test_${endpoint.name.toLowerCase().replace(/\s+/g, '_')}`,
+            steps: [{
+                    name: endpoint.name,
+                    method: endpoint.method,
+                    path: endpoint.path,
+                    headers: this.generateHeaders(endpoint),
+                    json: this.generateRequestBody(endpoint),
+                    extract: this.generateExtractions(endpoint)
+                }]
+        }));
+    }
+    extractParameters(operation, pathItem) {
+        const params = [];
+        // Operation-level parameters
+        if (operation.parameters) {
+            params.push(...this.parseParameters(operation.parameters));
+        }
+        // Path-level parameters
+        if (pathItem.parameters) {
+            params.push(...this.parseParameters(pathItem.parameters));
+        }
+        return params;
+    }
+    parseParameters(parameters) {
+        return parameters.map(param => ({
+            name: param.name,
+            in: param.in,
+            required: param.required || false,
+            type: param.schema?.type || param.type || 'string',
+            description: param.description,
+            example: param.example || param.schema?.example,
+            enum: param.schema?.enum || param.enum
+        }));
+    }
+    extractRequestBody(operation) {
+        if (!operation.requestBody)
+            return undefined;
+        const content = operation.requestBody.content || {};
+        const contentType = Object.keys(content)[0]; // Take first content type
+        if (!contentType)
+            return undefined;
+        return {
+            contentType,
+            schema: content[contentType].schema,
+            example: content[contentType].example,
+            required: operation.requestBody.required || false
+        };
+    }
+    extractResponses(operation) {
+        const responses = [];
+        for (const [statusCode, response] of Object.entries(operation.responses || {})) {
+            const content = response.content || {};
+            for (const [contentType, mediaType] of Object.entries(content)) {
+                responses.push({
+                    statusCode: parseInt(statusCode),
+                    contentType,
+                    schema: mediaType.schema,
+                    example: mediaType.example
+                });
+            }
+        }
+        return responses;
+    }
+    generateHeaders(endpoint) {
+        const headers = {};
+        endpoint.parameters?.forEach(param => {
+            if (param.in === 'header') {
+                headers[param.name] = param.example || `{{${param.name}}}`;
+            }
+        });
+        return headers;
+    }
+    generateRequestBody(endpoint) {
+        if (!endpoint.requestBody)
+            return undefined;
+        if (endpoint.requestBody.example) {
+            return endpoint.requestBody.example;
+        }
+        // Generate from schema
+        return this.generateFromSchema(endpoint.requestBody.schema);
+    }
+    generateExtractions(endpoint) {
+        const extractions = [];
+        // Extract common response fields that might be useful for correlation
+        endpoint.responses?.forEach(response => {
+            if (response.statusCode >= 200 && response.statusCode < 300 && response.schema) {
+                const commonFields = ['id', 'token', 'access_token', 'refresh_token', 'sessionId'];
+                commonFields.forEach(field => {
+                    if (this.schemaHasProperty(response.schema, field)) {
+                        extractions.push({
+                            name: field,
+                            type: 'json_path',
+                            expression: `$.${field}`
+                        });
+                    }
+                });
+            }
+        });
+        return extractions;
+    }
+    generateFromSchema(schema) {
+        if (!schema)
+            return {};
+        // Basic schema-to-example generation
+        if (schema.example)
+            return schema.example;
+        if (schema.properties) {
+            const example = {};
+            for (const [prop, propSchema] of Object.entries(schema.properties)) {
+                example[prop] = this.generateValueFromSchema(propSchema);
+            }
+            return example;
+        }
+        return {};
+    }
+    generateValueFromSchema(schema) {
+        if (schema.example !== undefined)
+            return schema.example;
+        if (schema.enum)
+            return schema.enum[0];
+        switch (schema.type) {
+            case 'string':
+                return schema.format === 'email' ? '{{faker.internet.email}}' : '{{faker.lorem.word}}';
+            case 'number':
+            case 'integer':
+                return '{{faker.number.int}}';
+            case 'boolean':
+                return true;
+            case 'array':
+                return [this.generateValueFromSchema(schema.items || {})];
+            case 'object':
+                return this.generateFromSchema(schema);
+            default:
+                return `{{${schema.type || 'value'}}}`;
+        }
+    }
+    schemaHasProperty(schema, property) {
+        return schema && schema.properties && schema.properties[property];
+    }
+}
+exports.OpenAPIImporter = OpenAPIImporter;

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

@@ -0,0 +1,42 @@
+import { ImportableEndpoint } from "../config/types/import-types";
+interface SoapVersion {
+    version: string;
+    bindingName: string;
+    description: string;
+}
+export declare class WSDLImporter {
+    private wsdlContent;
+    private selectedSoapVersions;
+    constructor(wsdlContent: string);
+    detectSoapVersions(): SoapVersion[];
+    setSoapVersions(versions: string[]): void;
+    extractServices(): ImportableEndpoint[];
+    generateOutputFilename(baseFilename: string): string;
+    generateScenarios(selectedServices: ImportableEndpoint[]): any[];
+    getWsdlUrl(selectedServices: ImportableEndpoint[]): string;
+    private extractServiceElements;
+    private extractPortElements;
+    private extractEndpointFromPort;
+    private isBindingVersionSelected;
+    private getSoapVersionFromBinding;
+    private extractOperationsFromBinding;
+    private extractSoapAction;
+    private getOperationDocumentation;
+    private parseSchemaElement;
+    private mapXsdType;
+    private createImportableEndpoint;
+    private getContentType;
+    private getResponseContentType;
+    private generateSOAPParameters;
+    private generateSOAPExample;
+    private generateSOAPResponseExample;
+    private generateSampleParameters;
+    private getSampleValue;
+    private generateArgsFromSchema;
+    private extractWsdlUrl;
+    private generateSOAPExtractions;
+    private getPathFromUrl;
+    private getTargetNamespace;
+    private extractAttribute;
+}
+export {};