@testsmith/testblocks 0.9.5 → 0.9.8

package/dist/server/openApiParser.js

@@ -0,0 +1,495 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOpenApiSpec = parseOpenApiSpec;
+exports.generateTestFiles = generateTestFiles;
+const swagger_parser_1 = __importDefault(require("@apidevtools/swagger-parser"));
+/**
+ * Parse an OpenAPI/Swagger spec from a URL or content string
+ */
+async function parseOpenApiSpec(source, isUrl = true) {
+    let api;
+    if (isUrl) {
+        api = await swagger_parser_1.default.dereference(source);
+    }
+    else {
+        // Parse from content string (JSON or YAML)
+        const content = source.trim();
+        let parsed;
+        if (content.startsWith('{')) {
+            parsed = JSON.parse(content);
+        }
+        else {
+            // Import yaml dynamically
+            const yaml = await Promise.resolve().then(() => __importStar(require('yaml')));
+            parsed = yaml.parse(content);
+        }
+        api = await swagger_parser_1.default.dereference(parsed);
+    }
+    return extractSpecInfo(api);
+}
+/**
+ * Extract structured information from a parsed OpenAPI spec
+ */
+function extractSpecInfo(api) {
+    const isV3 = 'openapi' in api;
+    // Extract info
+    const info = {
+        title: api.info.title,
+        version: api.info.version,
+        description: api.info.description,
+    };
+    // Extract servers
+    const servers = [];
+    if (isV3) {
+        const v3Api = api;
+        if (v3Api.servers) {
+            servers.push(...v3Api.servers.map(s => ({ url: s.url, description: s.description })));
+        }
+    }
+    else {
+        const v2Api = api;
+        const scheme = v2Api.schemes?.[0] || 'https';
+        const host = v2Api.host || 'localhost';
+        const basePath = v2Api.basePath || '';
+        servers.push({ url: `${scheme}://${host}${basePath}` });
+    }
+    // Extract security schemes
+    const securitySchemes = {};
+    if (isV3) {
+        const v3Api = api;
+        const schemes = v3Api.components?.securitySchemes || {};
+        for (const [name, scheme] of Object.entries(schemes)) {
+            if ('type' in scheme) {
+                securitySchemes[name] = extractSecurityScheme(scheme);
+            }
+        }
+    }
+    else {
+        const v2Api = api;
+        const schemes = v2Api.securityDefinitions || {};
+        for (const [name, scheme] of Object.entries(schemes)) {
+            securitySchemes[name] = extractSecuritySchemeV2(scheme);
+        }
+    }
+    // Extract tags
+    const tags = (api.tags || []).map(t => ({
+        name: t.name,
+        description: t.description,
+    }));
+    // Extract endpoints
+    const endpoints = [];
+    const paths = api.paths || {};
+    for (const [path, pathItem] of Object.entries(paths)) {
+        if (!pathItem)
+            continue;
+        const methods = ['get', 'post', 'put', 'patch', 'delete'];
+        for (const method of methods) {
+            const operation = pathItem[method];
+            if (!operation)
+                continue;
+            const endpoint = extractEndpoint(path, method, operation, pathItem, isV3);
+            endpoints.push(endpoint);
+        }
+    }
+    return { info, servers, endpoints, securitySchemes, tags };
+}
+/**
+ * Extract a single endpoint from an operation
+ */
+function extractEndpoint(path, method, operation, pathItem, isV3) {
+    // Combine path-level and operation-level parameters
+    const pathParams = (pathItem.parameters || []);
+    const opParams = (operation.parameters || []);
+    const allParams = [...pathParams, ...opParams];
+    // Extract parameters
+    const parameters = allParams.map(param => ({
+        name: param.name,
+        in: param.in,
+        required: param.required || false,
+        description: param.description,
+        schema: isV3
+            ? extractSchema(param.schema)
+            : extractSchemaV2(param),
+    }));
+    // Extract request body
+    let requestBody;
+    if (isV3) {
+        const v3Op = operation;
+        if (v3Op.requestBody && 'content' in v3Op.requestBody) {
+            const rb = v3Op.requestBody;
+            const contentType = Object.keys(rb.content)[0] || 'application/json';
+            const mediaType = rb.content[contentType];
+            requestBody = {
+                required: rb.required || false,
+                contentType,
+                schema: mediaType?.schema,
+                example: mediaType?.example || mediaType?.schema?.example,
+            };
+        }
+    }
+    else {
+        const v2Op = operation;
+        const bodyParam = allParams.find(p => p.in === 'body');
+        if (bodyParam) {
+            requestBody = {
+                required: bodyParam.required || false,
+                contentType: 'application/json',
+                schema: bodyParam.schema,
+                example: bodyParam.schema?.example,
+            };
+        }
+    }
+    // Extract responses
+    const responses = [];
+    for (const [statusCode, response] of Object.entries(operation.responses || {})) {
+        if (!response || '$ref' in response)
+            continue;
+        const resp = response;
+        let example;
+        let schema;
+        if (isV3) {
+            const v3Resp = resp;
+            const content = v3Resp.content?.['application/json'];
+            schema = content?.schema;
+            example = content?.example || content?.schema?.example;
+        }
+        else {
+            const v2Resp = resp;
+            schema = v2Resp.schema;
+            example = v2Resp.schema?.example;
+        }
+        responses.push({
+            statusCode,
+            description: resp.description,
+            schema,
+            example,
+        });
+    }
+    // Generate operation ID if not present
+    const operationId = operation.operationId || `${method}_${path.replace(/[^a-zA-Z0-9]/g, '_')}`;
+    return {
+        operationId,
+        method,
+        path,
+        summary: operation.summary,
+        description: operation.description,
+        tags: operation.tags || [],
+        parameters,
+        requestBody,
+        responses,
+        security: operation.security,
+        deprecated: operation.deprecated,
+    };
+}
+function extractSchema(schema) {
+    if (!schema)
+        return undefined;
+    return {
+        type: schema.type || 'string',
+        format: schema.format,
+        default: schema.default,
+        example: schema.example,
+    };
+}
+function extractSchemaV2(param) {
+    if (!('type' in param))
+        return undefined;
+    const p = param;
+    return {
+        type: p.type || 'string',
+        format: p.format,
+        default: p.default,
+        example: undefined, // V2 doesn't have example on parameters
+    };
+}
+function extractSecurityScheme(scheme) {
+    return {
+        type: scheme.type,
+        name: 'name' in scheme ? scheme.name : undefined,
+        in: 'in' in scheme ? scheme.in : undefined,
+        scheme: 'scheme' in scheme ? scheme.scheme : undefined,
+        bearerFormat: 'bearerFormat' in scheme ? scheme.bearerFormat : undefined,
+        description: scheme.description,
+    };
+}
+function extractSecuritySchemeV2(scheme) {
+    return {
+        type: scheme.type === 'basic' ? 'http' : scheme.type,
+        name: 'name' in scheme ? scheme.name : undefined,
+        in: 'in' in scheme ? scheme.in : undefined,
+        scheme: scheme.type === 'basic' ? 'basic' : undefined,
+        description: scheme.description,
+    };
+}
+/**
+ * Generate test files from selected endpoints
+ */
+function generateTestFiles(spec, selectedEndpoints, options) {
+    const endpoints = spec.endpoints.filter(e => selectedEndpoints.includes(e.operationId));
+    if (endpoints.length === 0) {
+        return [];
+    }
+    switch (options.fileStrategy) {
+        case 'single':
+            return [generateSingleFile(spec, endpoints, options)];
+        case 'per-tag':
+            return generatePerTagFiles(spec, endpoints, options);
+        case 'per-path':
+            return generatePerPathFiles(spec, endpoints, options);
+        default:
+            return [generateSingleFile(spec, endpoints, options)];
+    }
+}
+function generateSingleFile(spec, endpoints, options) {
+    const variables = extractVariables(endpoints, options);
+    const tests = endpoints.map(endpoint => generateTestCase(endpoint, options));
+    const testFile = {
+        version: '1.0.0',
+        name: spec.info.title,
+        description: spec.info.description || `API tests generated from ${spec.info.title} v${spec.info.version}`,
+        variables,
+        tests,
+    };
+    const fileName = sanitizeFileName(spec.info.title) + '.testblocks.json';
+    return { fileName, testFile };
+}
+function generatePerTagFiles(spec, endpoints, options) {
+    // Group endpoints by tag
+    const byTag = new Map();
+    for (const endpoint of endpoints) {
+        const tag = endpoint.tags[0] || 'default';
+        if (!byTag.has(tag)) {
+            byTag.set(tag, []);
+        }
+        byTag.get(tag).push(endpoint);
+    }
+    const files = [];
+    for (const [tag, tagEndpoints] of byTag) {
+        const variables = extractVariables(tagEndpoints, options);
+        const tests = tagEndpoints.map(endpoint => generateTestCase(endpoint, options));
+        const tagInfo = spec.tags.find(t => t.name === tag);
+        const testFile = {
+            version: '1.0.0',
+            name: `${spec.info.title} - ${tag}`,
+            description: tagInfo?.description || `API tests for ${tag}`,
+            variables,
+            tests,
+        };
+        const fileName = sanitizeFileName(`${spec.info.title}-${tag}`) + '.testblocks.json';
+        files.push({ fileName, testFile });
+    }
+    return files;
+}
+function generatePerPathFiles(spec, endpoints, options) {
+    // Group endpoints by base path (first segment)
+    const byPath = new Map();
+    for (const endpoint of endpoints) {
+        const segments = endpoint.path.split('/').filter(Boolean);
+        const basePath = segments[0] || 'root';
+        if (!byPath.has(basePath)) {
+            byPath.set(basePath, []);
+        }
+        byPath.get(basePath).push(endpoint);
+    }
+    const files = [];
+    for (const [basePath, pathEndpoints] of byPath) {
+        const variables = extractVariables(pathEndpoints, options);
+        const tests = pathEndpoints.map(endpoint => generateTestCase(endpoint, options));
+        const testFile = {
+            version: '1.0.0',
+            name: `${spec.info.title} - /${basePath}`,
+            description: `API tests for /${basePath} endpoints`,
+            variables,
+            tests,
+        };
+        const fileName = sanitizeFileName(`${spec.info.title}-${basePath}`) + '.testblocks.json';
+        files.push({ fileName, testFile });
+    }
+    return files;
+}
+function extractVariables(endpoints, options) {
+    const variables = {
+        baseUrl: {
+            type: 'string',
+            default: options.baseUrl || '',
+            description: 'API base URL',
+        },
+    };
+    // Extract unique path parameters
+    const pathParams = new Set();
+    for (const endpoint of endpoints) {
+        for (const param of endpoint.parameters) {
+            if (param.in === 'path') {
+                pathParams.add(param.name);
+            }
+        }
+    }
+    for (const paramName of pathParams) {
+        const param = endpoints
+            .flatMap(e => e.parameters)
+            .find(p => p.name === paramName && p.in === 'path');
+        variables[paramName] = {
+            type: (param?.schema?.type || 'string'),
+            default: param?.schema?.example || param?.schema?.default || '',
+            description: param?.description || `Path parameter: ${paramName}`,
+        };
+    }
+    return variables;
+}
+function generateTestCase(endpoint, options) {
+    const steps = [];
+    // Generate API call step
+    const apiStep = generateApiCallStep(endpoint, options);
+    steps.push(apiStep);
+    // Generate assertion step if enabled
+    if (options.generateAssertions) {
+        const assertionStep = generateAssertionStep(endpoint);
+        if (assertionStep) {
+            steps.push(assertionStep);
+        }
+    }
+    return {
+        id: `test-${endpoint.operationId}-${Date.now()}`,
+        name: `${endpoint.method.toUpperCase()} ${endpoint.path}`,
+        description: endpoint.summary || endpoint.description,
+        tags: endpoint.tags,
+        steps,
+    };
+}
+function generateApiCallStep(endpoint, options) {
+    const blockType = `api_${endpoint.method}`;
+    // Convert path parameters from {param} to ${param}
+    const urlPath = endpoint.path.replace(/\{([^}]+)\}/g, '${$1}');
+    const url = `\${baseUrl}${urlPath}`;
+    const params = {
+        URL: url,
+    };
+    // Add request body for POST/PUT/PATCH
+    if (['post', 'put', 'patch'].includes(endpoint.method) && endpoint.requestBody) {
+        let body = '{}';
+        if (options.includeExamples && endpoint.requestBody.example) {
+            body = JSON.stringify(endpoint.requestBody.example, null, 2);
+        }
+        else if (endpoint.requestBody.schema) {
+            body = generateSchemaExample(endpoint.requestBody.schema);
+        }
+        params.BODY = body;
+    }
+    return {
+        id: `step-${endpoint.operationId}-call-${Date.now()}`,
+        type: blockType,
+        params,
+    };
+}
+function generateAssertionStep(endpoint) {
+    // Find the first 2xx response
+    const successResponse = endpoint.responses.find(r => r.statusCode.startsWith('2'));
+    if (!successResponse) {
+        return null;
+    }
+    const statusCode = parseInt(successResponse.statusCode, 10);
+    return {
+        id: `step-${endpoint.operationId}-assert-${Date.now()}`,
+        type: 'api_assert_status',
+        params: {
+            STATUS: isNaN(statusCode) ? 200 : statusCode,
+        },
+    };
+}
+function generateSchemaExample(schema) {
+    // Simple schema-to-example generation
+    const type = schema.type;
+    if (schema.example !== undefined) {
+        return JSON.stringify(schema.example, null, 2);
+    }
+    switch (type) {
+        case 'object': {
+            const properties = schema.properties;
+            if (!properties)
+                return '{}';
+            const obj = {};
+            for (const [key, prop] of Object.entries(properties)) {
+                obj[key] = getDefaultValueForType(prop.type, prop.example, prop.format);
+            }
+            return JSON.stringify(obj, null, 2);
+        }
+        case 'array': {
+            const items = schema.items;
+            if (!items)
+                return '[]';
+            const itemValue = getDefaultValueForType(items.type, items.example, items.format);
+            return JSON.stringify([itemValue], null, 2);
+        }
+        default:
+            return '{}';
+    }
+}
+function getDefaultValueForType(type, example, format) {
+    if (example !== undefined)
+        return example;
+    switch (type) {
+        case 'string':
+            if (format === 'email')
+                return 'user@example.com';
+            if (format === 'date')
+                return '2024-01-01';
+            if (format === 'date-time')
+                return '2024-01-01T00:00:00Z';
+            if (format === 'uuid')
+                return '00000000-0000-0000-0000-000000000000';
+            return 'string';
+        case 'integer':
+        case 'number':
+            return 0;
+        case 'boolean':
+            return true;
+        case 'array':
+            return [];
+        case 'object':
+            return {};
+        default:
+            return null;
+    }
+}
+function sanitizeFileName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}

package/dist/server/startServer.d.ts

@@ -2,6 +2,7 @@ export interface ServerOptions {
     port?: number;
     pluginsDir?: string;
     globalsDir?: string;
+    projectDir?: string;
     open?: boolean;
 }
 export declare function startServer(options?: ServerOptions): Promise<void>;