@testsmith/testblocks 0.9.4 → 0.9.7

package/dist/core/blocks/utils/apiUtils.d.ts

@@ -0,0 +1,81 @@
+import { ExecutionContext } from '../../types';
+/**
+ * Parse header string into an object.
+ * Supports JSON format or key:value format.
+ *
+ * @param headersStr - The headers string (JSON or key:value pairs)
+ * @param context - The execution context for variable resolution
+ * @returns The parsed headers object
+ */
+export declare function parseHeaders(headersStr: string, context: ExecutionContext): Record<string, string>;
+/**
+ * Parse an HTTP response into a structured object.
+ *
+ * @param response - The fetch Response object
+ * @returns Parsed response with status, headers, and body
+ */
+export declare function parseResponse(response: Response): Promise<{
+    status: number;
+    headers: Record<string, string>;
+    body: unknown;
+}>;
+/**
+ * Get a value from an object by dot-notation path.
+ * Supports array indexing like "items[0]".
+ *
+ * @param obj - The object to traverse
+ * @param path - The dot-notation path (e.g., "data.user.name" or "items[0].id")
+ * @returns The value at the path, or undefined if not found
+ */
+export declare function getValueByPath(obj: unknown, path: string): unknown;
+/**
+ * Extract value from an XPath node.
+ *
+ * @param node - The XPath node
+ * @returns The string value of the node
+ */
+export declare function getNodeValue(node: unknown): string | null;
+/**
+ * Get the last API response from context.
+ *
+ * @param context - The execution context
+ * @returns The last response or throws if none available
+ */
+export declare function getLastResponse(context: ExecutionContext): {
+    status: number;
+    headers: Record<string, string>;
+    body: unknown;
+};
+/**
+ * Get context headers (set via api_set_header/api_set_headers blocks).
+ *
+ * @param context - The execution context
+ * @returns The headers object
+ */
+export declare function getContextHeaders(context: ExecutionContext): Record<string, string>;
+/**
+ * Set context headers.
+ *
+ * @param context - The execution context
+ * @param headers - The headers to set
+ */
+export declare function setContextHeaders(context: ExecutionContext, headers: Record<string, string>): void;
+/**
+ * Merge headers with context headers and inline headers.
+ *
+ * @param context - The execution context
+ * @param inlineHeadersStr - Optional inline headers string
+ * @returns The merged headers
+ */
+export declare function mergeHeaders(context: ExecutionContext, inlineHeadersStr?: string): Record<string, string>;
+/**
+ * Store an API response in the context.
+ *
+ * @param context - The execution context
+ * @param response - The parsed response to store
+ */
+export declare function storeResponse(context: ExecutionContext, response: {
+    status: number;
+    headers: Record<string, string>;
+    body: unknown;
+}): void;

package/dist/core/blocks/utils/apiUtils.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHeaders = parseHeaders;
+exports.parseResponse = parseResponse;
+exports.getValueByPath = getValueByPath;
+exports.getNodeValue = getNodeValue;
+exports.getLastResponse = getLastResponse;
+exports.getContextHeaders = getContextHeaders;
+exports.setContextHeaders = setContextHeaders;
+exports.mergeHeaders = mergeHeaders;
+exports.storeResponse = storeResponse;
+const variableUtils_1 = require("./variableUtils");
+/**
+ * Parse header string into an object.
+ * Supports JSON format or key:value format.
+ *
+ * @param headersStr - The headers string (JSON or key:value pairs)
+ * @param context - The execution context for variable resolution
+ * @returns The parsed headers object
+ */
+function parseHeaders(headersStr, context) {
+    if (!headersStr || !headersStr.trim())
+        return {};
+    const resolved = (0, variableUtils_1.resolveVariables)(headersStr, context);
+    // Try JSON format first: {"Authorization": "Bearer token"}
+    try {
+        const parsed = JSON.parse(resolved);
+        if (typeof parsed === 'object' && parsed !== null) {
+            return parsed;
+        }
+    }
+    catch {
+        // Not JSON, try key:value format
+    }
+    // Try key:value format (one per line or semicolon-separated)
+    // Example: "Authorization: Bearer token; Content-Type: application/json"
+    const headers = {};
+    const pairs = resolved.split(/[;\n]/).map(s => s.trim()).filter(s => s);
+    for (const pair of pairs) {
+        const colonIndex = pair.indexOf(':');
+        if (colonIndex > 0) {
+            const key = pair.slice(0, colonIndex).trim();
+            const value = pair.slice(colonIndex + 1).trim();
+            headers[key] = value;
+        }
+    }
+    return headers;
+}
+/**
+ * Parse an HTTP response into a structured object.
+ *
+ * @param response - The fetch Response object
+ * @returns Parsed response with status, headers, and body
+ */
+async function parseResponse(response) {
+    const headers = {};
+    response.headers.forEach((value, key) => {
+        headers[key] = value;
+    });
+    let body;
+    const contentType = response.headers.get('content-type') || '';
+    if (contentType.includes('application/json')) {
+        body = await response.json();
+    }
+    else {
+        body = await response.text();
+    }
+    return { status: response.status, headers, body };
+}
+/**
+ * Get a value from an object by dot-notation path.
+ * Supports array indexing like "items[0]".
+ *
+ * @param obj - The object to traverse
+ * @param path - The dot-notation path (e.g., "data.user.name" or "items[0].id")
+ * @returns The value at the path, or undefined if not found
+ */
+function getValueByPath(obj, path) {
+    if (!path)
+        return obj;
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        // Handle array indexing like "items[0]"
+        const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
+        if (arrayMatch) {
+            const [, key, index] = arrayMatch;
+            current = current[key];
+            if (Array.isArray(current)) {
+                current = current[parseInt(index, 10)];
+            }
+        }
+        else {
+            current = current[part];
+        }
+    }
+    return current;
+}
+/**
+ * Extract value from an XPath node.
+ *
+ * @param node - The XPath node
+ * @returns The string value of the node
+ */
+function getNodeValue(node) {
+    if (!node)
+        return null;
+    const n = node;
+    // Text node or attribute
+    if (n.nodeValue !== undefined) {
+        return n.nodeValue;
+    }
+    // Element node - get text content
+    if (n.textContent !== undefined) {
+        return n.textContent;
+    }
+    // Fallback to string representation
+    if (n.toString) {
+        return n.toString();
+    }
+    return null;
+}
+/**
+ * Get the last API response from context.
+ *
+ * @param context - The execution context
+ * @returns The last response or throws if none available
+ */
+function getLastResponse(context) {
+    const response = context.variables.get('__lastResponse');
+    if (!response) {
+        throw new Error('No response available. Make sure to call an API request first.');
+    }
+    return response;
+}
+/**
+ * Get context headers (set via api_set_header/api_set_headers blocks).
+ *
+ * @param context - The execution context
+ * @returns The headers object
+ */
+function getContextHeaders(context) {
+    return context.variables.get('__requestHeaders') || {};
+}
+/**
+ * Set context headers.
+ *
+ * @param context - The execution context
+ * @param headers - The headers to set
+ */
+function setContextHeaders(context, headers) {
+    context.variables.set('__requestHeaders', headers);
+}
+/**
+ * Merge headers with context headers and inline headers.
+ *
+ * @param context - The execution context
+ * @param inlineHeadersStr - Optional inline headers string
+ * @returns The merged headers
+ */
+function mergeHeaders(context, inlineHeadersStr) {
+    const contextHeaders = getContextHeaders(context);
+    const inlineHeaders = inlineHeadersStr ? parseHeaders(inlineHeadersStr, context) : {};
+    return { ...contextHeaders, ...inlineHeaders };
+}
+/**
+ * Store an API response in the context.
+ *
+ * @param context - The execution context
+ * @param response - The parsed response to store
+ */
+function storeResponse(context, response) {
+    context.variables.set('__lastResponse', response);
+}

package/dist/core/blocks/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { resolveVariables, resolveSimpleVariables, } from './variableUtils';
+export { parseHeaders, parseResponse, getValueByPath, getNodeValue, getLastResponse, getContextHeaders, setContextHeaders, mergeHeaders, storeResponse, } from './apiUtils';

package/dist/core/blocks/utils/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeResponse = exports.mergeHeaders = exports.setContextHeaders = exports.getContextHeaders = exports.getLastResponse = exports.getNodeValue = exports.getValueByPath = exports.parseResponse = exports.parseHeaders = exports.resolveSimpleVariables = exports.resolveVariables = void 0;
+var variableUtils_1 = require("./variableUtils");
+Object.defineProperty(exports, "resolveVariables", { enumerable: true, get: function () { return variableUtils_1.resolveVariables; } });
+Object.defineProperty(exports, "resolveSimpleVariables", { enumerable: true, get: function () { return variableUtils_1.resolveSimpleVariables; } });
+var apiUtils_1 = require("./apiUtils");
+Object.defineProperty(exports, "parseHeaders", { enumerable: true, get: function () { return apiUtils_1.parseHeaders; } });
+Object.defineProperty(exports, "parseResponse", { enumerable: true, get: function () { return apiUtils_1.parseResponse; } });
+Object.defineProperty(exports, "getValueByPath", { enumerable: true, get: function () { return apiUtils_1.getValueByPath; } });
+Object.defineProperty(exports, "getNodeValue", { enumerable: true, get: function () { return apiUtils_1.getNodeValue; } });
+Object.defineProperty(exports, "getLastResponse", { enumerable: true, get: function () { return apiUtils_1.getLastResponse; } });
+Object.defineProperty(exports, "getContextHeaders", { enumerable: true, get: function () { return apiUtils_1.getContextHeaders; } });
+Object.defineProperty(exports, "setContextHeaders", { enumerable: true, get: function () { return apiUtils_1.setContextHeaders; } });
+Object.defineProperty(exports, "mergeHeaders", { enumerable: true, get: function () { return apiUtils_1.mergeHeaders; } });
+Object.defineProperty(exports, "storeResponse", { enumerable: true, get: function () { return apiUtils_1.storeResponse; } });

package/dist/core/blocks/utils/variableUtils.d.ts

@@ -0,0 +1,19 @@
+import { ExecutionContext } from '../../types';
+/**
+ * Resolve variable references in a text string.
+ * Supports ${varName} and ${varName.property.path} syntax.
+ *
+ * @param text - The text containing variable references
+ * @param context - The execution context containing variables
+ * @returns The text with variables resolved
+ */
+export declare function resolveVariables(text: string, context: ExecutionContext): string;
+/**
+ * Simple variable resolution that only handles ${varName} syntax.
+ * Used in data-driven contexts where nested paths are not needed.
+ *
+ * @param text - The text containing variable references
+ * @param context - The execution context
+ * @returns The text with variables resolved
+ */
+export declare function resolveSimpleVariables(text: string, context: ExecutionContext): string;

package/dist/core/blocks/utils/variableUtils.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVariables = resolveVariables;
+exports.resolveSimpleVariables = resolveSimpleVariables;
+/**
+ * Resolve variable references in a text string.
+ * Supports ${varName} and ${varName.property.path} syntax.
+ *
+ * @param text - The text containing variable references
+ * @param context - The execution context containing variables
+ * @returns The text with variables resolved
+ */
+function resolveVariables(text, context) {
+    // Match ${varName} or ${varName.property.path}
+    return text.replace(/\$\{([\w.]+)\}/g, (match, path) => {
+        const parts = path.split('.');
+        const varName = parts[0];
+        // Check param prefix first (for procedures)
+        let value = context.variables.get(`__param_${varName}`);
+        // Then check current data (for data-driven tests)
+        if (value === undefined && context.currentData?.values[varName] !== undefined) {
+            value = context.currentData.values[varName];
+        }
+        // Then check regular variables
+        if (value === undefined) {
+            value = context.variables.get(varName);
+        }
+        // Navigate through object properties if path has dots
+        if (parts.length > 1 && value !== undefined && value !== null) {
+            for (let i = 1; i < parts.length; i++) {
+                if (value === undefined || value === null)
+                    break;
+                value = value[parts[i]];
+            }
+        }
+        if (value === undefined || value === null) {
+            return match; // Keep original if not found
+        }
+        // Return stringified value
+        if (typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+        return String(value);
+    });
+}
+/**
+ * Simple variable resolution that only handles ${varName} syntax.
+ * Used in data-driven contexts where nested paths are not needed.
+ *
+ * @param text - The text containing variable references
+ * @param context - The execution context
+ * @returns The text with variables resolved
+ */
+function resolveSimpleVariables(text, context) {
+    return text.replace(/\$\{(\w+)\}/g, (_, varName) => {
+        // Check param prefix first
+        const paramValue = context.variables.get(`__param_${varName}`);
+        if (paramValue !== undefined) {
+            return String(paramValue);
+        }
+        // Then check current data
+        if (context.currentData?.values[varName] !== undefined) {
+            return String(context.currentData.values[varName]);
+        }
+        // Then regular variables
+        const value = context.variables.get(varName);
+        return value !== undefined ? String(value) : '';
+    });
+}

package/dist/server/index.js

@@ -48,6 +48,7 @@ const reporters_1 = require("../cli/reporters");
 const plugins_1 = require("./plugins");
 const globals_1 = require("./globals");
 const codegenManager_1 = require("./codegenManager");
+const openApiParser_1 = require("./openApiParser");
 // Set plugins directory (default to examples/plugins or can be overridden via env)
 const pluginsDir = process.env.PLUGINS_DIR || path_1.default.join(process.cwd(), 'examples', 'plugins');
 (0, plugins_1.setPluginsDirectory)(pluginsDir);
@@ -370,6 +371,108 @@ app.get('/api/record/status/:sessionId', (req, res) => {
         error: session.error,
     });
 });
+// ===== OpenAPI Import Endpoints =====
+// Parse an OpenAPI/Swagger spec from URL
+app.post('/api/openapi/parse', async (req, res) => {
+    try {
+        const { url } = req.body;
+        if (!url) {
+            return res.status(400).json({ error: 'URL is required' });
+        }
+        console.log(`Parsing OpenAPI spec from URL: ${url}`);
+        const spec = await (0, openApiParser_1.parseOpenApiSpec)(url, true);
+        res.json({
+            info: spec.info,
+            servers: spec.servers,
+            endpoints: spec.endpoints.map(e => ({
+                operationId: e.operationId,
+                method: e.method,
+                path: e.path,
+                summary: e.summary,
+                description: e.description,
+                tags: e.tags,
+                deprecated: e.deprecated,
+                hasRequestBody: !!e.requestBody,
+                responses: e.responses.map(r => r.statusCode),
+            })),
+            securitySchemes: spec.securitySchemes,
+            tags: spec.tags,
+        });
+    }
+    catch (error) {
+        console.error('Failed to parse OpenAPI spec:', error);
+        res.status(500).json({
+            error: 'Failed to parse OpenAPI spec',
+            message: error.message,
+        });
+    }
+});
+// Parse an OpenAPI/Swagger spec from content
+app.post('/api/openapi/parse-content', async (req, res) => {
+    try {
+        const { content } = req.body;
+        if (!content) {
+            return res.status(400).json({ error: 'Content is required' });
+        }
+        console.log('Parsing OpenAPI spec from content');
+        const spec = await (0, openApiParser_1.parseOpenApiSpec)(content, false);
+        res.json({
+            info: spec.info,
+            servers: spec.servers,
+            endpoints: spec.endpoints.map(e => ({
+                operationId: e.operationId,
+                method: e.method,
+                path: e.path,
+                summary: e.summary,
+                description: e.description,
+                tags: e.tags,
+                deprecated: e.deprecated,
+                hasRequestBody: !!e.requestBody,
+                responses: e.responses.map(r => r.statusCode),
+            })),
+            securitySchemes: spec.securitySchemes,
+            tags: spec.tags,
+        });
+    }
+    catch (error) {
+        console.error('Failed to parse OpenAPI spec:', error);
+        res.status(500).json({
+            error: 'Failed to parse OpenAPI spec',
+            message: error.message,
+        });
+    }
+});
+// Generate test files from selected endpoints
+app.post('/api/openapi/generate', async (req, res) => {
+    try {
+        const { url, content, selectedEndpoints, options } = req.body;
+        if (!url && !content) {
+            return res.status(400).json({ error: 'Either URL or content is required' });
+        }
+        if (!selectedEndpoints || selectedEndpoints.length === 0) {
+            return res.status(400).json({ error: 'No endpoints selected' });
+        }
+        console.log(`Generating tests for ${selectedEndpoints.length} endpoints`);
+        const spec = url
+            ? await (0, openApiParser_1.parseOpenApiSpec)(url, true)
+            : await (0, openApiParser_1.parseOpenApiSpec)(content, false);
+        const files = (0, openApiParser_1.generateTestFiles)(spec, selectedEndpoints, options);
+        res.json({
+            files: files.map(f => ({
+                fileName: f.fileName,
+                testFile: f.testFile,
+                testCount: f.testFile.tests.length,
+            })),
+        });
+    }
+    catch (error) {
+        console.error('Failed to generate test files:', error);
+        res.status(500).json({
+            error: 'Failed to generate test files',
+            message: error.message,
+        });
+    }
+});
 // ===== Report Generation Endpoints =====
 // Generate HTML report from test results
 app.post('/api/reports/html', (req, res) => {
@@ -459,15 +562,18 @@ process.on('SIGINT', () => {
 app.listen(PORT, () => {
     console.log(`TestBlocks server running on http://localhost:${PORT}`);
     console.log('API endpoints:');
-    console.log('  GET  /api/health          - Health check');
-    console.log('  GET  /api/plugins         - List plugins');
-    console.log('  GET  /api/globals         - Get globals and snippets');
-    console.log('  POST /api/run             - Run all tests');
-    console.log('  POST /api/run/:id         - Run single test');
-    console.log('  POST /api/validate        - Validate test file');
-    console.log('  POST /api/record/start    - Start recording session');
-    console.log('  POST /api/record/stop     - Stop recording and get steps');
-    console.log('  GET  /api/record/status   - Get recording session status');
-    console.log('  POST /api/reports/html    - Generate HTML report');
-    console.log('  POST /api/reports/junit   - Generate JUnit XML report');
+    console.log('  GET  /api/health              - Health check');
+    console.log('  GET  /api/plugins             - List plugins');
+    console.log('  GET  /api/globals             - Get globals and snippets');
+    console.log('  POST /api/run                 - Run all tests');
+    console.log('  POST /api/run/:id             - Run single test');
+    console.log('  POST /api/validate            - Validate test file');
+    console.log('  POST /api/record/start        - Start recording session');
+    console.log('  POST /api/record/stop         - Stop recording and get steps');
+    console.log('  GET  /api/record/status       - Get recording session status');
+    console.log('  POST /api/openapi/parse       - Parse OpenAPI spec from URL');
+    console.log('  POST /api/openapi/parse-content - Parse OpenAPI spec from content');
+    console.log('  POST /api/openapi/generate    - Generate tests from OpenAPI spec');
+    console.log('  POST /api/reports/html        - Generate HTML report');
+    console.log('  POST /api/reports/junit       - Generate JUnit XML report');
 });

package/dist/server/openApiParser.d.ts

@@ -0,0 +1,82 @@
+import { TestFile } from '../core';
+export interface ParsedParameter {
+    name: string;
+    in: 'path' | 'query' | 'header' | 'cookie';
+    required: boolean;
+    description?: string;
+    schema?: {
+        type: string;
+        format?: string;
+        default?: unknown;
+        example?: unknown;
+    };
+}
+export interface ParsedRequestBody {
+    required: boolean;
+    contentType: string;
+    schema?: Record<string, unknown>;
+    example?: unknown;
+}
+export interface ParsedResponse {
+    statusCode: string;
+    description?: string;
+    schema?: Record<string, unknown>;
+    example?: unknown;
+}
+export interface ParsedEndpoint {
+    operationId: string;
+    method: 'get' | 'post' | 'put' | 'patch' | 'delete';
+    path: string;
+    summary?: string;
+    description?: string;
+    tags: string[];
+    parameters: ParsedParameter[];
+    requestBody?: ParsedRequestBody;
+    responses: ParsedResponse[];
+    security?: Record<string, string[]>[];
+    deprecated?: boolean;
+}
+export interface ParsedSecurityScheme {
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    name?: string;
+    in?: 'header' | 'query' | 'cookie';
+    scheme?: string;
+    bearerFormat?: string;
+    description?: string;
+}
+export interface ParsedSpec {
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    servers: {
+        url: string;
+        description?: string;
+    }[];
+    endpoints: ParsedEndpoint[];
+    securitySchemes: Record<string, ParsedSecurityScheme>;
+    tags: {
+        name: string;
+        description?: string;
+    }[];
+}
+export interface ImportOptions {
+    baseUrl: string;
+    fileStrategy: 'single' | 'per-tag' | 'per-path';
+    includeExamples: boolean;
+    generateAssertions: boolean;
+    authVariablePrefix: string;
+}
+export interface GeneratedTestFile {
+    fileName: string;
+    testFile: TestFile;
+}
+/**
+ * Parse an OpenAPI/Swagger spec from a URL or content string
+ */
+export declare function parseOpenApiSpec(source: string, isUrl?: boolean): Promise<ParsedSpec>;
+/**
+ * Generate test files from selected endpoints
+ */
+export declare function generateTestFiles(spec: ParsedSpec, selectedEndpoints: string[], options: ImportOptions): GeneratedTestFile[];