@testsmith/testblocks 0.6.0 → 0.7.0

package/dist/core/executor/BaseTestExecutor.d.ts

@@ -0,0 +1,60 @@
+import { Browser, Page, BrowserContext } from 'playwright';
+import { TestFile, TestStep, StepResult, ExecutionContext, Logger, Plugin, ProcedureDefinition } from '../types';
+export interface ExecutorOptions {
+    headless?: boolean;
+    timeout?: number;
+    baseUrl?: string;
+    variables?: Record<string, unknown>;
+    plugins?: Plugin[];
+    testIdAttribute?: string;
+    baseDir?: string;
+}
+/**
+ * Base class for test execution providing shared functionality
+ * for both server and CLI executors
+ */
+export declare abstract class BaseTestExecutor {
+    protected options: ExecutorOptions;
+    protected browser: Browser | null;
+    protected browserContext: BrowserContext | null;
+    protected page: Page | null;
+    protected plugins: Map<string, Plugin>;
+    protected procedures: Map<string, ProcedureDefinition>;
+    constructor(options?: ExecutorOptions);
+    /**
+     * Initialize browser for test execution
+     */
+    initialize(): Promise<void>;
+    /**
+     * Cleanup browser resources
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Check if a test file requires browser initialization
+     */
+    protected requiresBrowser(testFile: TestFile): boolean;
+    /**
+     * Register custom blocks from procedure definitions
+     */
+    protected registerCustomBlocksFromProcedures(procedures: Record<string, ProcedureDefinition>): void;
+    /**
+     * Execute a single step
+     */
+    protected runStep(step: TestStep, context: ExecutionContext): Promise<StepResult>;
+    /**
+     * Resolve step parameters, executing nested blocks
+     */
+    protected resolveParams(params: Record<string, unknown>, context: ExecutionContext): Promise<Record<string, unknown>>;
+    /**
+     * Create a logger instance
+     */
+    protected createLogger(): Logger;
+    /**
+     * Resolve variable defaults from globals format
+     */
+    protected resolveVariableDefaults(vars?: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Extract steps from Blockly state
+     */
+    protected extractStepsFromBlocklyState(state: unknown): TestStep[];
+}

package/dist/core/executor/BaseTestExecutor.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTestExecutor = void 0;
+const playwright_1 = require("playwright");
+const blocks_1 = require("../blocks");
+const blocklyParser_1 = require("../utils/blocklyParser");
+const variableResolver_1 = require("../utils/variableResolver");
+/**
+ * Base class for test execution providing shared functionality
+ * for both server and CLI executors
+ */
+class BaseTestExecutor {
+    constructor(options = {}) {
+        this.browser = null;
+        this.browserContext = null;
+        this.page = null;
+        this.plugins = new Map();
+        this.procedures = new Map();
+        this.options = {
+            headless: true,
+            timeout: 30000,
+            ...options,
+        };
+        if (options.plugins) {
+            options.plugins.forEach(plugin => {
+                this.plugins.set(plugin.name, plugin);
+            });
+        }
+    }
+    /**
+     * Initialize browser for test execution
+     */
+    async initialize() {
+        if (this.options.testIdAttribute) {
+            playwright_1.selectors.setTestIdAttribute(this.options.testIdAttribute);
+        }
+        this.browser = await playwright_1.chromium.launch({
+            headless: this.options.headless,
+        });
+        this.browserContext = await this.browser.newContext();
+        this.page = await this.browserContext.newPage();
+        if (this.options.timeout) {
+            this.page.setDefaultTimeout(this.options.timeout);
+        }
+    }
+    /**
+     * Cleanup browser resources
+     */
+    async cleanup() {
+        if (this.page)
+            await this.page.close();
+        if (this.browserContext)
+            await this.browserContext.close();
+        if (this.browser)
+            await this.browser.close();
+        this.page = null;
+        this.browserContext = null;
+        this.browser = null;
+    }
+    /**
+     * Check if a test file requires browser initialization
+     */
+    requiresBrowser(testFile) {
+        const hasWebStep = (steps) => {
+            return steps.some(step => step.type.startsWith('web_'));
+        };
+        const hasWebStepInState = (state) => {
+            const steps = blocklyParser_1.BlocklyParser.extractSteps(state);
+            return hasWebStep(steps);
+        };
+        // Check lifecycle hooks
+        if (testFile.beforeAll && hasWebStepInState(testFile.beforeAll))
+            return true;
+        if (testFile.afterAll && hasWebStepInState(testFile.afterAll))
+            return true;
+        if (testFile.beforeEach && hasWebStepInState(testFile.beforeEach))
+            return true;
+        if (testFile.afterEach && hasWebStepInState(testFile.afterEach))
+            return true;
+        // Check all tests
+        for (const test of testFile.tests) {
+            if (hasWebStepInState(test.steps))
+                return true;
+            if (test.beforeEach && hasWebStepInState(test.beforeEach))
+                return true;
+            if (test.afterEach && hasWebStepInState(test.afterEach))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Register custom blocks from procedure definitions
+     */
+    registerCustomBlocksFromProcedures(procedures) {
+        Object.entries(procedures).forEach(([name, proc]) => {
+            (0, blocks_1.registerProcedure)(name, proc);
+            this.procedures.set(name, proc);
+            if (!proc.steps || proc.steps.length === 0)
+                return;
+            const blockType = `custom_${proc.name.toLowerCase().replace(/\s+/g, '_')}`;
+            if ((0, blocks_1.getBlock)(blockType))
+                return;
+            const blockDef = {
+                type: blockType,
+                category: 'Custom',
+                color: '#607D8B',
+                tooltip: proc.description || `Custom block: ${proc.name}`,
+                inputs: (proc.params || []).map(param => ({
+                    name: param.name.toUpperCase(),
+                    type: 'field',
+                    fieldType: param.type === 'number' ? 'number' : 'text',
+                    default: param.default,
+                })),
+                previousStatement: true,
+                nextStatement: true,
+                execute: async (params, context) => {
+                    context.logger.info(`Executing custom block: ${proc.name}`);
+                    (proc.params || []).forEach(p => {
+                        const paramKey = p.name.toUpperCase();
+                        let value = params[paramKey];
+                        if (value !== undefined) {
+                            if (typeof value === 'string') {
+                                value = variableResolver_1.VariableResolver.resolve(value, context);
+                            }
+                            context.variables.set(p.name, value);
+                            context.logger.debug(`Set procedure param: ${p.name} = "${value}"`);
+                        }
+                    });
+                    return {
+                        customBlock: true,
+                        name: proc.name,
+                        steps: proc.steps,
+                    };
+                },
+            };
+            (0, blocks_1.registerBlock)(blockDef);
+        });
+    }
+    /**
+     * Execute a single step
+     */
+    async runStep(step, context) {
+        const startTime = Date.now();
+        // Run beforeStep hooks
+        for (const plugin of this.plugins.values()) {
+            if (plugin.hooks?.beforeStep) {
+                await plugin.hooks.beforeStep(context, step);
+            }
+        }
+        let status = 'passed';
+        let output;
+        let error;
+        try {
+            const blockDef = (0, blocks_1.getBlock)(step.type);
+            if (!blockDef) {
+                throw new Error(`Unknown block type: ${step.type}`);
+            }
+            const resolvedParams = await this.resolveParams(step.params, context);
+            output = await blockDef.execute(resolvedParams, context);
+            // Handle custom blocks that return steps to execute
+            if (output && typeof output === 'object' && 'customBlock' in output) {
+                const customOutput = output;
+                for (const childStep of customOutput.steps) {
+                    const childResult = await this.runStep(childStep, context);
+                    if (childResult.status === 'failed' || childResult.status === 'error') {
+                        status = childResult.status;
+                        error = childResult.error;
+                        break;
+                    }
+                }
+            }
+            // Handle compound actions
+            if (output && typeof output === 'object' && 'compoundAction' in output) {
+                const compoundOutput = output;
+                for (const childStep of compoundOutput.steps) {
+                    const childResult = await this.runStep(childStep, context);
+                    if (childResult.status === 'failed' || childResult.status === 'error') {
+                        status = childResult.status;
+                        error = childResult.error;
+                        break;
+                    }
+                }
+            }
+            // Handle procedure calls
+            if (output && typeof output === 'object' && 'procedureCall' in output) {
+                const procOutput = output;
+                for (const [argName, argValue] of Object.entries(procOutput.args)) {
+                    let resolvedValue = argValue;
+                    if (typeof argValue === 'string') {
+                        resolvedValue = variableResolver_1.VariableResolver.resolve(argValue, context);
+                    }
+                    context.variables.set(argName, resolvedValue);
+                }
+                if (procOutput.procedure.steps) {
+                    for (const childStep of procOutput.procedure.steps) {
+                        const childResult = await this.runStep(childStep, context);
+                        if (childResult.status === 'failed' || childResult.status === 'error') {
+                            status = childResult.status;
+                            error = childResult.error;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            status = 'failed';
+            error = {
+                message: err.message,
+                stack: err.stack,
+            };
+        }
+        // Capture screenshot on failure for web tests
+        let screenshot;
+        if (status === 'failed' && step.type.startsWith('web_') && context.page) {
+            try {
+                const page = context.page;
+                const buffer = await page.screenshot({ fullPage: true });
+                screenshot = buffer.toString('base64');
+            }
+            catch {
+                // Ignore screenshot errors
+            }
+        }
+        const result = {
+            stepId: step.id,
+            stepType: step.type,
+            status,
+            duration: Date.now() - startTime,
+            output,
+            error,
+            screenshot,
+        };
+        // Run afterStep hooks
+        for (const plugin of this.plugins.values()) {
+            if (plugin.hooks?.afterStep) {
+                await plugin.hooks.afterStep(context, step, result);
+            }
+        }
+        return result;
+    }
+    /**
+     * Resolve step parameters, executing nested blocks
+     */
+    async resolveParams(params, context) {
+        const resolved = {};
+        for (const [key, value] of Object.entries(params)) {
+            if (value && typeof value === 'object' && 'type' in value && 'id' in value) {
+                // This is a connected block - execute it to get the value
+                const nestedStep = value;
+                const blockDef = (0, blocks_1.getBlock)(nestedStep.type);
+                if (blockDef) {
+                    const nestedParams = await this.resolveParams(nestedStep.params || {}, context);
+                    resolved[key] = await blockDef.execute(nestedParams, context);
+                }
+            }
+            else {
+                resolved[key] = value;
+            }
+        }
+        return resolved;
+    }
+    /**
+     * Create a logger instance
+     */
+    createLogger() {
+        return {
+            info: (message, data) => {
+                console.log(`[INFO] ${message}`, data !== undefined ? data : '');
+            },
+            warn: (message, data) => {
+                console.warn(`[WARN] ${message}`, data !== undefined ? data : '');
+            },
+            error: (message, data) => {
+                console.error(`[ERROR] ${message}`, data !== undefined ? data : '');
+            },
+            debug: (message, data) => {
+                if (process.env.DEBUG) {
+                    console.debug(`[DEBUG] ${message}`, data !== undefined ? data : '');
+                }
+            },
+        };
+    }
+    /**
+     * Resolve variable defaults from globals format
+     */
+    resolveVariableDefaults(vars) {
+        return (0, variableResolver_1.resolveVariableDefaults)(vars);
+    }
+    /**
+     * Extract steps from Blockly state
+     */
+    extractStepsFromBlocklyState(state) {
+        return blocklyParser_1.BlocklyParser.extractSteps(state);
+    }
+}
+exports.BaseTestExecutor = BaseTestExecutor;

package/dist/core/executor/index.d.ts

@@ -0,0 +1 @@
+export { BaseTestExecutor, type ExecutorOptions } from './BaseTestExecutor';

package/dist/core/executor/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTestExecutor = void 0;
+var BaseTestExecutor_1 = require("./BaseTestExecutor");
+Object.defineProperty(exports, "BaseTestExecutor", { enumerable: true, get: function () { return BaseTestExecutor_1.BaseTestExecutor; } });

package/dist/core/index.d.ts

@@ -1,5 +1,6 @@
 export * from './types';
 export * from './blocks';
 export * from './plugins';
+export * from './utils';
 export { builtInBlocks, blockRegistry, registerBlock, registerBlocks, getBlock, getAllBlocks, getBlocksByCategory, getCategories, } from './blocks';
 export { registerPlugin, getPlugin, getAllPlugins, getAllPluginBlocks, unregisterPlugin, createPlugin, createBlock, createActionBlock, createValueBlock, createAssertionBlock, } from './plugins';

package/dist/core/index.js

@@ -21,6 +21,10 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./blocks"), exports);
 // Plugins
 __exportStar(require("./plugins"), exports);
+// Utilities (browser-safe only)
+__exportStar(require("./utils"), exports);
+// Note: BaseTestExecutor is in ./executor but uses Playwright (Node.js only)
+// Import it directly from '@/core/executor' in server/CLI code
 // Re-export specific items for convenience
 var blocks_1 = require("./blocks");
 Object.defineProperty(exports, "builtInBlocks", { enumerable: true, get: function () { return blocks_1.builtInBlocks; } });

package/dist/core/types.d.ts

@@ -46,6 +46,7 @@ export interface TestCase {
     afterEach?: TestStep[];
     steps: TestStep[];
     tags?: string[];
+    softAssertions?: boolean;
 }
 export interface TestDataSet {
     name?: string;
@@ -81,6 +82,14 @@ export interface BlockInput {
 export interface BlockOutput {
     type: string | string[];
 }
+export interface SoftAssertionError {
+    message: string;
+    stepId?: string;
+    stepType?: string;
+    expected?: unknown;
+    actual?: unknown;
+    timestamp: string;
+}
 export interface ExecutionContext {
     variables: Map<string, unknown>;
     results: TestResult[];
@@ -94,6 +103,8 @@ export interface ExecutionContext {
     currentData?: TestDataSet;
     dataIndex?: number;
     testIdAttribute?: string;
+    softAssertions?: boolean;
+    softAssertionErrors?: SoftAssertionError[];
 }
 export interface Logger {
     info(message: string, data?: unknown): void;
@@ -117,6 +128,7 @@ export interface TestResult {
     };
     isLifecycle?: boolean;
     lifecycleType?: 'beforeAll' | 'afterAll' | 'beforeEach' | 'afterEach';
+    softAssertionErrors?: SoftAssertionError[];
 }
 export interface StepResult {
     stepId: string;

package/dist/core/utils/blocklyParser.d.ts

@@ -0,0 +1,18 @@
+import { TestStep } from '../types';
+/**
+ * Utility class for parsing Blockly state into TestSteps
+ */
+export declare class BlocklyParser {
+    /**
+     * Extract steps from Blockly serialization state or direct step array
+     */
+    static extractSteps(state: unknown): TestStep[];
+    /**
+     * Convert Blockly blocks array to TestSteps
+     */
+    static blocksToSteps(blocks: unknown[]): TestStep[];
+    /**
+     * Convert a single Blockly block to a TestStep
+     */
+    static blockToStep(block: Record<string, unknown>): TestStep | null;
+}

package/dist/core/utils/blocklyParser.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlocklyParser = void 0;
+/**
+ * Utility class for parsing Blockly state into TestSteps
+ */
+class BlocklyParser {
+    /**
+     * Extract steps from Blockly serialization state or direct step array
+     */
+    static extractSteps(state) {
+        if (!state || typeof state !== 'object')
+            return [];
+        const stateObj = state;
+        // Handle Blockly serialization format
+        if ('blocks' in stateObj && typeof stateObj.blocks === 'object') {
+            const blocks = stateObj.blocks;
+            if ('blocks' in blocks && Array.isArray(blocks.blocks)) {
+                return this.blocksToSteps(blocks.blocks);
+            }
+        }
+        // Handle direct array of steps
+        if (Array.isArray(state)) {
+            return state;
+        }
+        return [];
+    }
+    /**
+     * Convert Blockly blocks array to TestSteps
+     */
+    static blocksToSteps(blocks) {
+        const steps = [];
+        for (const block of blocks) {
+            const step = this.blockToStep(block);
+            if (step) {
+                steps.push(step);
+                // Handle next block in chain
+                let currentBlock = block;
+                while (currentBlock.next) {
+                    const nextBlock = currentBlock.next.block;
+                    const nextStep = this.blockToStep(nextBlock);
+                    if (nextStep) {
+                        steps.push(nextStep);
+                    }
+                    currentBlock = nextBlock;
+                }
+            }
+        }
+        return steps;
+    }
+    /**
+     * Convert a single Blockly block to a TestStep
+     */
+    static blockToStep(block) {
+        if (!block || !block.type)
+            return null;
+        const step = {
+            id: block.id || `step-${Date.now()}`,
+            type: block.type,
+            params: {},
+        };
+        // Extract field values
+        if (block.fields && typeof block.fields === 'object') {
+            for (const [name, value] of Object.entries(block.fields)) {
+                step.params[name] = value;
+            }
+        }
+        // Extract inputs (connected blocks)
+        if (block.inputs && typeof block.inputs === 'object') {
+            for (const [name, input] of Object.entries(block.inputs)) {
+                const inputObj = input;
+                if (inputObj.block) {
+                    // Recursively convert connected block
+                    const connectedStep = this.blockToStep(inputObj.block);
+                    if (connectedStep) {
+                        step.params[name] = connectedStep;
+                    }
+                }
+            }
+        }
+        return step;
+    }
+}
+exports.BlocklyParser = BlocklyParser;

package/dist/core/utils/dataLoader.d.ts

@@ -0,0 +1,9 @@
+import { TestDataSet } from '../types';
+/**
+ * Parse CSV content into TestDataSet array
+ */
+export declare function parseCSV(content: string): TestDataSet[];
+/**
+ * Load data from a file (CSV or JSON)
+ */
+export declare function loadDataFromFile(filePath: string, baseDir?: string): TestDataSet[];

package/dist/core/utils/dataLoader.js

@@ -0,0 +1,117 @@
+"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.parseCSV = parseCSV;
+exports.loadDataFromFile = loadDataFromFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Parse CSV content into TestDataSet array
+ */
+function parseCSV(content) {
+    const lines = content.trim().split('\n');
+    if (lines.length < 2)
+        return []; // Need header + at least one data row
+    const headers = lines[0].split(',').map(h => h.trim());
+    const dataSets = [];
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        // Simple CSV parsing (handles basic quoted values)
+        const values = [];
+        let current = '';
+        let inQuotes = false;
+        for (const char of line) {
+            if (char === '"') {
+                inQuotes = !inQuotes;
+            }
+            else if (char === ',' && !inQuotes) {
+                values.push(current.trim());
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        values.push(current.trim());
+        const row = {};
+        headers.forEach((header, idx) => {
+            const val = values[idx] ?? '';
+            // Try to parse as number or boolean
+            if (val === 'true') {
+                row[header] = true;
+            }
+            else if (val === 'false') {
+                row[header] = false;
+            }
+            else if (val !== '' && !isNaN(Number(val))) {
+                row[header] = Number(val);
+            }
+            else {
+                row[header] = val;
+            }
+        });
+        dataSets.push({ name: `Row ${i}`, values: row });
+    }
+    return dataSets;
+}
+/**
+ * Load data from a file (CSV or JSON)
+ */
+function loadDataFromFile(filePath, baseDir) {
+    const resolvedPath = baseDir && !path.isAbsolute(filePath)
+        ? path.join(baseDir, filePath)
+        : filePath;
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`Data file not found: ${resolvedPath}`);
+    }
+    const content = fs.readFileSync(resolvedPath, 'utf-8');
+    const ext = path.extname(resolvedPath).toLowerCase();
+    if (ext === '.csv') {
+        return parseCSV(content);
+    }
+    else if (ext === '.json') {
+        const jsonData = JSON.parse(content);
+        if (Array.isArray(jsonData)) {
+            return jsonData.map((item, idx) => ({
+                name: item.name || `Item ${idx + 1}`,
+                values: item.values || item,
+            }));
+        }
+        throw new Error('JSON data file must contain an array');
+    }
+    throw new Error(`Unsupported data file format: ${ext}`);
+}

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

@@ -0,0 +1,2 @@
+export { VariableResolver, resolveVariableDefaults } from './variableResolver';
+export { BlocklyParser } from './blocklyParser';

package/dist/core/utils/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlocklyParser = exports.resolveVariableDefaults = exports.VariableResolver = void 0;
+// Variable resolution utilities (browser-safe)
+var variableResolver_1 = require("./variableResolver");
+Object.defineProperty(exports, "VariableResolver", { enumerable: true, get: function () { return variableResolver_1.VariableResolver; } });
+Object.defineProperty(exports, "resolveVariableDefaults", { enumerable: true, get: function () { return variableResolver_1.resolveVariableDefaults; } });
+// Blockly parsing utilities (browser-safe)
+var blocklyParser_1 = require("./blocklyParser");
+Object.defineProperty(exports, "BlocklyParser", { enumerable: true, get: function () { return blocklyParser_1.BlocklyParser; } });
+// Note: dataLoader and logger use Node.js modules and should be imported directly
+// by server/CLI code, not through this index (to avoid browser bundling issues)