testblocks 0.1.0

package/dist/core/blocks/data-driven.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataDrivenBlocks = void 0;
+// Data-Driven Testing Blocks
+exports.dataDrivenBlocks = [
+    // Define test data inline
+    {
+        type: 'data_define',
+        category: 'Data',
+        color: '#00897B',
+        tooltip: 'Define test data sets for data-driven testing',
+        inputs: [
+            { name: 'DATA_JSON', type: 'field', fieldType: 'text', default: '[{"name": "test1", "value": 1}]' },
+        ],
+        output: { type: 'Array' },
+        execute: async (params, context) => {
+            const json = resolveVariables(params.DATA_JSON, context);
+            return JSON.parse(json);
+        },
+    },
+    // Load data from variable
+    {
+        type: 'data_from_variable',
+        category: 'Data',
+        color: '#00897B',
+        tooltip: 'Get test data from a variable',
+        inputs: [
+            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
+        ],
+        output: { type: 'Array' },
+        execute: async (params, context) => {
+            const name = params.NAME;
+            return context.variables.get(name) || [];
+        },
+    },
+    // Get current data value
+    {
+        type: 'data_get_current',
+        category: 'Data',
+        color: '#00897B',
+        tooltip: 'Get a value from the current data set',
+        inputs: [
+            { name: 'KEY', type: 'field', fieldType: 'text', required: true },
+        ],
+        output: { type: ['String', 'Number', 'Boolean', 'Object', 'Array'] },
+        execute: async (params, context) => {
+            const key = params.KEY;
+            if (!context.currentData) {
+                throw new Error('No data set available. This block must be used inside a data-driven test.');
+            }
+            const value = context.currentData.values[key];
+            if (value === undefined) {
+                context.logger.warn(`Data key "${key}" not found in current data set`);
+            }
+            return value;
+        },
+    },
+    // Get current iteration index
+    {
+        type: 'data_get_index',
+        category: 'Data',
+        color: '#00897B',
+        tooltip: 'Get the current data iteration index (0-based)',
+        inputs: [],
+        output: { type: 'Number' },
+        execute: async (params, context) => {
+            return context.dataIndex ?? 0;
+        },
+    },
+    // Get current data set name
+    {
+        type: 'data_get_name',
+        category: 'Data',
+        color: '#00897B',
+        tooltip: 'Get the name of the current data set',
+        inputs: [],
+        output: { type: 'String' },
+        execute: async (params, context) => {
+            return context.currentData?.name ?? `Iteration ${(context.dataIndex ?? 0) + 1}`;
+        },
+    },
+    // For each data - iterate over data array
+    {
+        type: 'data_foreach',
+        category: 'Data',
+        color: '#00897B',
+        tooltip: 'Run steps for each item in a data set',
+        inputs: [
+            { name: 'DATA', type: 'value', check: 'Array', required: true },
+            { name: 'ITEM_VAR', type: 'field', fieldType: 'text', default: 'item' },
+            { name: 'INDEX_VAR', type: 'field', fieldType: 'text', default: 'index' },
+            { name: 'DO', type: 'statement' },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, _context) => {
+            const data = params.DATA;
+            const itemVar = params.ITEM_VAR;
+            const indexVar = params.INDEX_VAR;
+            return {
+                dataLoop: true,
+                data,
+                itemVar,
+                indexVar,
+                statement: 'DO',
+            };
+        },
+    },
+    // Create data row
+    {
+        type: 'data_row',
+        category: 'Data',
+        color: '#00897B',
+        tooltip: 'Create a single data row with key-value pairs',
+        inputs: [
+            { name: 'NAME', type: 'field', fieldType: 'text', default: '' },
+            { name: 'JSON', type: 'field', fieldType: 'text', default: '{}' },
+        ],
+        output: { type: 'Object' },
+        execute: async (params, context) => {
+            const name = params.NAME;
+            const json = resolveVariables(params.JSON, context);
+            return {
+                name: name || undefined,
+                values: JSON.parse(json),
+            };
+        },
+    },
+    // Data table - create multiple rows at once
+    {
+        type: 'data_table',
+        category: 'Data',
+        color: '#00897B',
+        tooltip: 'Create a data table with headers and rows',
+        inputs: [
+            { name: 'HEADERS', type: 'field', fieldType: 'text', default: 'username, password, expected' },
+            { name: 'ROWS', type: 'field', fieldType: 'text', default: 'user1, pass1, true\nuser2, pass2, false' },
+        ],
+        output: { type: 'Array' },
+        execute: async (params, context) => {
+            const headersStr = params.HEADERS;
+            const rowsStr = resolveVariables(params.ROWS, context);
+            const headers = headersStr.split(',').map(h => h.trim());
+            const rows = rowsStr.split('\n').filter(r => r.trim());
+            return rows.map((row, index) => {
+                const values = row.split(',').map(v => {
+                    const trimmed = v.trim();
+                    // Try to parse as JSON for numbers, booleans, etc.
+                    try {
+                        return JSON.parse(trimmed);
+                    }
+                    catch {
+                        return trimmed;
+                    }
+                });
+                const obj = {};
+                headers.forEach((header, i) => {
+                    obj[header] = values[i];
+                });
+                return {
+                    name: `Row ${index + 1}`,
+                    values: obj,
+                };
+            });
+        },
+    },
+    // CSV-style data
+    {
+        type: 'data_csv',
+        category: 'Data',
+        color: '#00897B',
+        tooltip: 'Parse CSV-style data (first row as headers)',
+        inputs: [
+            { name: 'CSV', type: 'field', fieldType: 'text', default: 'name,value\ntest1,100\ntest2,200' },
+        ],
+        output: { type: 'Array' },
+        execute: async (params, context) => {
+            const csv = resolveVariables(params.CSV, context);
+            const lines = csv.split('\n').filter(l => l.trim());
+            if (lines.length < 2) {
+                return [];
+            }
+            const headers = lines[0].split(',').map(h => h.trim());
+            return lines.slice(1).map((line, index) => {
+                const values = line.split(',').map(v => {
+                    const trimmed = v.trim();
+                    try {
+                        return JSON.parse(trimmed);
+                    }
+                    catch {
+                        return trimmed;
+                    }
+                });
+                const obj = {};
+                headers.forEach((header, i) => {
+                    obj[header] = values[i];
+                });
+                return {
+                    name: `Row ${index + 1}`,
+                    values: obj,
+                };
+            });
+        },
+    },
+    // Generate range of numbers
+    {
+        type: 'data_range',
+        category: 'Data',
+        color: '#00897B',
+        tooltip: 'Generate a range of numbers as data',
+        inputs: [
+            { name: 'START', type: 'field', fieldType: 'number', default: 1 },
+            { name: 'END', type: 'field', fieldType: 'number', default: 10 },
+            { name: 'STEP', type: 'field', fieldType: 'number', default: 1 },
+            { name: 'VAR_NAME', type: 'field', fieldType: 'text', default: 'n' },
+        ],
+        output: { type: 'Array' },
+        execute: async (params, _context) => {
+            const start = params.START;
+            const end = params.END;
+            const step = params.STEP;
+            const varName = params.VAR_NAME;
+            const result = [];
+            for (let i = start; i <= end; i += step) {
+                result.push({
+                    name: `${varName}=${i}`,
+                    values: { [varName]: i },
+                });
+            }
+            return result;
+        },
+    },
+];
+// Helper function
+function resolveVariables(text, context) {
+    return text.replace(/\$\{(\w+)\}/g, (_, varName) => {
+        // First check current data
+        if (context.currentData?.values[varName] !== undefined) {
+            return String(context.currentData.values[varName]);
+        }
+        // Then check variables
+        const value = context.variables.get(varName);
+        return value !== undefined ? String(value) : '';
+    });
+}

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

@@ -0,0 +1,15 @@
+export { apiBlocks } from './api';
+export { playwrightBlocks } from './playwright';
+export { logicBlocks } from './logic';
+export { lifecycleBlocks } from './lifecycle';
+export { dataDrivenBlocks } from './data-driven';
+export { procedureBlocks, registerProcedure, getProcedure, clearProcedures } from './procedures';
+import { BlockDefinition } from '../types';
+export declare const builtInBlocks: BlockDefinition[];
+export declare const blockRegistry: Map<string, BlockDefinition>;
+export declare function registerBlock(block: BlockDefinition): void;
+export declare function registerBlocks(blocks: BlockDefinition[]): void;
+export declare function getBlock(type: string): BlockDefinition | undefined;
+export declare function getAllBlocks(): BlockDefinition[];
+export declare function getBlocksByCategory(category: string): BlockDefinition[];
+export declare function getCategories(): string[];

package/dist/core/blocks/index.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blockRegistry = exports.builtInBlocks = exports.clearProcedures = exports.getProcedure = exports.registerProcedure = exports.procedureBlocks = exports.dataDrivenBlocks = exports.lifecycleBlocks = exports.logicBlocks = exports.playwrightBlocks = exports.apiBlocks = void 0;
+exports.registerBlock = registerBlock;
+exports.registerBlocks = registerBlocks;
+exports.getBlock = getBlock;
+exports.getAllBlocks = getAllBlocks;
+exports.getBlocksByCategory = getBlocksByCategory;
+exports.getCategories = getCategories;
+var api_1 = require("./api");
+Object.defineProperty(exports, "apiBlocks", { enumerable: true, get: function () { return api_1.apiBlocks; } });
+var playwright_1 = require("./playwright");
+Object.defineProperty(exports, "playwrightBlocks", { enumerable: true, get: function () { return playwright_1.playwrightBlocks; } });
+var logic_1 = require("./logic");
+Object.defineProperty(exports, "logicBlocks", { enumerable: true, get: function () { return logic_1.logicBlocks; } });
+var lifecycle_1 = require("./lifecycle");
+Object.defineProperty(exports, "lifecycleBlocks", { enumerable: true, get: function () { return lifecycle_1.lifecycleBlocks; } });
+var data_driven_1 = require("./data-driven");
+Object.defineProperty(exports, "dataDrivenBlocks", { enumerable: true, get: function () { return data_driven_1.dataDrivenBlocks; } });
+var procedures_1 = require("./procedures");
+Object.defineProperty(exports, "procedureBlocks", { enumerable: true, get: function () { return procedures_1.procedureBlocks; } });
+Object.defineProperty(exports, "registerProcedure", { enumerable: true, get: function () { return procedures_1.registerProcedure; } });
+Object.defineProperty(exports, "getProcedure", { enumerable: true, get: function () { return procedures_1.getProcedure; } });
+Object.defineProperty(exports, "clearProcedures", { enumerable: true, get: function () { return procedures_1.clearProcedures; } });
+const api_2 = require("./api");
+const playwright_2 = require("./playwright");
+const logic_2 = require("./logic");
+const lifecycle_2 = require("./lifecycle");
+const data_driven_2 = require("./data-driven");
+const procedures_2 = require("./procedures");
+// All built-in blocks
+exports.builtInBlocks = [
+    ...api_2.apiBlocks,
+    ...playwright_2.playwrightBlocks,
+    ...logic_2.logicBlocks,
+    ...lifecycle_2.lifecycleBlocks,
+    ...data_driven_2.dataDrivenBlocks,
+    ...procedures_2.procedureBlocks,
+];
+// Block registry for runtime lookup
+exports.blockRegistry = new Map();
+// Initialize registry with built-in blocks
+exports.builtInBlocks.forEach(block => {
+    exports.blockRegistry.set(block.type, block);
+});
+// Function to register custom blocks (for plugins)
+function registerBlock(block) {
+    exports.blockRegistry.set(block.type, block);
+}
+// Function to register multiple blocks
+function registerBlocks(blocks) {
+    blocks.forEach(block => registerBlock(block));
+}
+// Get a block definition by type
+function getBlock(type) {
+    return exports.blockRegistry.get(type);
+}
+// Get all registered blocks
+function getAllBlocks() {
+    return Array.from(exports.blockRegistry.values());
+}
+// Get blocks by category
+function getBlocksByCategory(category) {
+    return getAllBlocks().filter(block => block.category === category);
+}
+// Get all categories
+function getCategories() {
+    const categories = new Set();
+    getAllBlocks().forEach(block => categories.add(block.category));
+    return Array.from(categories);
+}

package/dist/core/blocks/lifecycle.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const lifecycleBlocks: BlockDefinition[];

package/dist/core/blocks/lifecycle.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lifecycleBlocks = void 0;
+// Lifecycle and Hook Blocks
+exports.lifecycleBlocks = [
+    // Test Case - container for test steps
+    {
+        type: 'test_case',
+        category: 'Tests',
+        color: '#1E88E5',
+        tooltip: 'A test case containing steps to execute',
+        inputs: [
+            { name: 'NAME', type: 'field', fieldType: 'multiline', default: 'Test Case' },
+            { name: 'STEPS', type: 'statement' },
+        ],
+        execute: async (params, _context) => {
+            // Marker block - steps are executed by the executor
+            return { testCase: true, name: params.NAME, statement: 'STEPS' };
+        },
+    },
+    // Data-Driven Test Case - runs multiple times with different data
+    {
+        type: 'test_case_data_driven',
+        category: 'Tests',
+        color: '#1565C0',
+        tooltip: 'A data-driven test case that runs for each row of data (CSV format: header row, then data rows)',
+        inputs: [
+            { name: 'NAME', type: 'field', fieldType: 'text', default: 'Data-Driven Test' },
+            { name: 'DATA', type: 'field', fieldType: 'multiline', default: 'username,password,expected\nuser1,pass1,true\nuser2,pass2,false' },
+            { name: 'STEPS', type: 'statement' },
+        ],
+        execute: async (params, _context) => {
+            // Marker block - actual data parsing and execution handled by executor
+            const csvData = params.DATA;
+            const rows = csvData.trim().split('\n').map(row => row.split(',').map(cell => cell.trim()));
+            if (rows.length < 2) {
+                return { testCase: true, name: params.NAME, dataDriven: true, data: [], statement: 'STEPS' };
+            }
+            const headers = rows[0];
+            const data = rows.slice(1).map((row, index) => {
+                const values = {};
+                headers.forEach((header, i) => {
+                    let value = row[i] || '';
+                    // Try to parse as boolean or number
+                    if (value === 'true')
+                        value = true;
+                    else if (value === 'false')
+                        value = false;
+                    else if (!isNaN(Number(value)) && value !== '')
+                        value = Number(value);
+                    values[header] = value;
+                });
+                return { name: `Row ${index + 1}`, values };
+            });
+            return { testCase: true, name: params.NAME, dataDriven: true, data, statement: 'STEPS' };
+        },
+    },
+    // Before All - runs once before all tests
+    {
+        type: 'lifecycle_before_all',
+        category: 'Lifecycle',
+        color: '#8E24AA',
+        tooltip: 'Steps to run once before all tests in the suite',
+        inputs: [
+            { name: 'DO', type: 'statement' },
+        ],
+        execute: async (_params, _context) => {
+            // Marker block - actual execution handled by executor
+            return { lifecycle: 'beforeAll', statement: 'DO' };
+        },
+    },
+    // After All - runs once after all tests
+    {
+        type: 'lifecycle_after_all',
+        category: 'Lifecycle',
+        color: '#8E24AA',
+        tooltip: 'Steps to run once after all tests in the suite',
+        inputs: [
+            { name: 'DO', type: 'statement' },
+        ],
+        execute: async (_params, _context) => {
+            return { lifecycle: 'afterAll', statement: 'DO' };
+        },
+    },
+    // Before Each - runs before each test
+    {
+        type: 'lifecycle_before_each',
+        category: 'Lifecycle',
+        color: '#8E24AA',
+        tooltip: 'Steps to run before each test',
+        inputs: [
+            { name: 'DO', type: 'statement' },
+        ],
+        execute: async (_params, _context) => {
+            return { lifecycle: 'beforeEach', statement: 'DO' };
+        },
+    },
+    // After Each - runs after each test
+    {
+        type: 'lifecycle_after_each',
+        category: 'Lifecycle',
+        color: '#8E24AA',
+        tooltip: 'Steps to run after each test',
+        inputs: [
+            { name: 'DO', type: 'statement' },
+        ],
+        execute: async (_params, _context) => {
+            return { lifecycle: 'afterEach', statement: 'DO' };
+        },
+    },
+    // Setup - alias for beforeEach with clearer naming
+    {
+        type: 'lifecycle_setup',
+        category: 'Lifecycle',
+        color: '#8E24AA',
+        tooltip: 'Setup steps to run before the test',
+        inputs: [
+            { name: 'DESCRIPTION', type: 'field', fieldType: 'text', default: 'Setup' },
+            { name: 'DO', type: 'statement' },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            context.logger.info(`Setup: ${params.DESCRIPTION}`);
+            return { lifecycle: 'setup', statement: 'DO' };
+        },
+    },
+    // Teardown - alias for afterEach with clearer naming
+    {
+        type: 'lifecycle_teardown',
+        category: 'Lifecycle',
+        color: '#8E24AA',
+        tooltip: 'Teardown steps to run after the test',
+        inputs: [
+            { name: 'DESCRIPTION', type: 'field', fieldType: 'text', default: 'Teardown' },
+            { name: 'DO', type: 'statement' },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            context.logger.info(`Teardown: ${params.DESCRIPTION}`);
+            return { lifecycle: 'teardown', statement: 'DO' };
+        },
+    },
+    // Cleanup on failure - only runs if test fails
+    {
+        type: 'lifecycle_on_failure',
+        category: 'Lifecycle',
+        color: '#C62828',
+        tooltip: 'Steps to run only if the test fails',
+        inputs: [
+            { name: 'DO', type: 'statement' },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (_params, _context) => {
+            return { lifecycle: 'onFailure', statement: 'DO' };
+        },
+    },
+    // Skip test conditionally
+    {
+        type: 'lifecycle_skip_if',
+        category: 'Lifecycle',
+        color: '#757575',
+        tooltip: 'Skip the rest of the test if condition is true',
+        inputs: [
+            { name: 'CONDITION', type: 'value', check: 'Boolean', required: true },
+            { name: 'REASON', type: 'field', fieldType: 'text', default: 'Condition not met' },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, _context) => {
+            const condition = params.CONDITION;
+            const reason = params.REASON;
+            if (condition) {
+                throw { skip: true, reason };
+            }
+        },
+    },
+    // Retry on failure
+    {
+        type: 'lifecycle_retry',
+        category: 'Lifecycle',
+        color: '#FF6F00',
+        tooltip: 'Retry steps on failure',
+        inputs: [
+            { name: 'TIMES', type: 'field', fieldType: 'number', default: 3 },
+            { name: 'DELAY', type: 'field', fieldType: 'number', default: 1000 },
+            { name: 'DO', type: 'statement' },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, _context) => {
+            const times = params.TIMES;
+            const delay = params.DELAY;
+            return { retry: true, times, delay, statement: 'DO' };
+        },
+    },
+];

package/dist/core/blocks/logic.d.ts

@@ -0,0 +1,2 @@
+import { BlockDefinition } from '../types';
+export declare const logicBlocks: BlockDefinition[];