@testsmith/testblocks 0.5.0 → 0.7.0

package/dist/cli/executor.d.ts

@@ -1,10 +1,11 @@
-import { TestFile, TestCase, TestResult, Plugin, TestDataSet } from '../core';
+import { TestFile, TestCase, TestResult, Plugin, ProcedureDefinition, TestDataSet } from '../core';
 export interface ExecutorOptions {
     headless?: boolean;
     timeout?: number;
     baseUrl?: string;
     variables?: Record<string, unknown>;
     plugins?: Plugin[];
+    procedures?: Record<string, ProcedureDefinition>;
 }
 export declare class TestExecutor {
     private options;
@@ -23,11 +24,13 @@ export declare class TestExecutor {
     runTest(test: TestCase, testFile: TestFile): Promise<TestResult>;
     private runSteps;
     private resolveVariableDefaults;
+    private registerCustomBlocksFromProcedures;
     private extractStepsFromBlocklyState;
     private blocksToSteps;
     private blockToStep;
     private runStep;
     private executeProcedure;
+    private resolveVariablePlaceholders;
     private resolveParams;
     private createLogger;
 }

package/dist/cli/executor.js

@@ -20,6 +20,13 @@ class TestExecutor {
                 this.plugins.set(plugin.name, plugin);
             });
         }
+        // Register project-level procedures from options
+        if (options.procedures) {
+            for (const [name, procedure] of Object.entries(options.procedures)) {
+                this.procedures.set(name, procedure);
+            }
+            this.registerCustomBlocksFromProcedures(options.procedures);
+        }
     }
     async initialize() {
         this.browser = await playwright_1.chromium.launch({
@@ -81,6 +88,8 @@ class TestExecutor {
             for (const [name, procedure] of Object.entries(testFile.procedures)) {
                 this.procedures.set(name, procedure);
             }
+            // Also register them as custom blocks so custom_xxx blocks work
+            this.registerCustomBlocksFromProcedures(testFile.procedures);
         }
         // Create base context for hooks
         const baseContext = this.createBaseContext(testFile.variables);
@@ -122,7 +131,7 @@ class TestExecutor {
         return {
             variables: new Map(Object.entries({
                 ...this.resolveVariableDefaults(fileVariables),
-                ...this.options.variables,
+                ...this.resolveVariableDefaults(this.options.variables),
             })),
             results: [],
             browser: this.browser,
@@ -347,6 +356,56 @@ class TestExecutor {
         }
         return resolved;
     }
+    registerCustomBlocksFromProcedures(procedures) {
+        Object.entries(procedures).forEach(([_name, proc]) => {
+            if (!proc.steps || proc.steps.length === 0)
+                return;
+            const blockType = `custom_${proc.name.toLowerCase().replace(/\s+/g, '_')}`;
+            // Check if already registered
+            if ((0, core_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}`);
+                    // Set procedure parameters in context.variables so ${paramName} references work
+                    // Resolve any ${variable} placeholders in the parameter values first
+                    (proc.params || []).forEach(p => {
+                        const paramKey = p.name.toUpperCase();
+                        let value = params[paramKey];
+                        if (value !== undefined) {
+                            // Resolve variable placeholders like ${email} from context
+                            if (typeof value === 'string') {
+                                value = this.resolveVariablePlaceholders(value, context);
+                            }
+                            context.variables.set(p.name, value);
+                        }
+                    });
+                    // Execute the procedure's steps directly
+                    const steps = this.extractStepsFromBlocklyState(proc.steps);
+                    for (const step of steps) {
+                        const result = await this.runStep(step, context);
+                        if (result.status !== 'passed') {
+                            throw new Error(`Procedure ${proc.name} failed: ${result.error?.message}`);
+                        }
+                    }
+                    return { customBlock: true, name: proc.name };
+                },
+            };
+            (0, core_1.registerBlock)(blockDef);
+        });
+    }
     extractStepsFromBlocklyState(state) {
         if (!state || typeof state !== 'object')
             return [];
@@ -482,9 +541,20 @@ class TestExecutor {
             throw new Error(`Procedure not found: ${name}`);
         }
         context.logger.info(`  Executing procedure: ${name}`);
-        // Set up parameter variables with prefix
+        // Save original variable values to restore after procedure execution
+        const savedValues = new Map();
+        // Set up parameter variables (procedure steps reference them directly as ${paramName})
         for (const [key, value] of Object.entries(args)) {
-            context.variables.set(`__param_${key}`, value);
+            // Resolve any ${variable} placeholders in the argument value
+            let resolvedValue = value;
+            if (typeof value === 'string' && value.includes('${')) {
+                resolvedValue = this.resolveVariablePlaceholders(value, context);
+            }
+            // Save original value if it exists
+            if (context.variables.has(key)) {
+                savedValues.set(key, context.variables.get(key));
+            }
+            context.variables.set(key, resolvedValue);
         }
         // Execute procedure steps
         const steps = this.extractStepsFromBlocklyState(procedure.steps);
@@ -503,12 +573,38 @@ class TestExecutor {
                 }
             }
         }
-        // Clean up parameter variables
+        // Restore original variable values
+        for (const [key, originalValue] of savedValues) {
+            context.variables.set(key, originalValue);
+        }
+        // Remove variables that didn't exist before
         for (const key of Object.keys(args)) {
-            context.variables.delete(`__param_${key}`);
+            if (!savedValues.has(key)) {
+                context.variables.delete(key);
+            }
         }
         return returnValue;
     }
+    resolveVariablePlaceholders(text, context) {
+        return text.replace(/\$\{([\w.]+)\}/g, (match, path) => {
+            const parts = path.split('.');
+            const varName = parts[0];
+            let value = context.variables.get(varName);
+            // Handle dot notation for nested object access
+            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;
+            if (typeof value === 'object')
+                return JSON.stringify(value);
+            return String(value);
+        });
+    }
     async resolveParams(params, context) {
         const resolved = {};
         for (const [key, value] of Object.entries(params)) {

package/dist/cli/index.js

@@ -41,6 +41,21 @@ const glob_1 = require("glob");
 const executor_1 = require("./executor");
 const reporters_1 = require("./reporters");
 const startServer_1 = require("../server/startServer");
+/**
+ * Search up the directory tree for globals.json starting from the given directory
+ */
+function findGlobalsFile(startDir) {
+    let currentDir = path.resolve(startDir);
+    const root = path.parse(currentDir).root;
+    while (currentDir !== root) {
+        const globalsPath = path.join(currentDir, 'globals.json');
+        if (fs.existsSync(globalsPath)) {
+            return globalsPath;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
 const program = new commander_1.Command();
 program
     .name('testblocks')
@@ -73,9 +88,15 @@ program
             process.exit(1);
         }
         console.log(`Found ${files.length} test file(s)\n`);
-        // Load globals.json if it exists
+        // Load globals.json - search up directory tree from first test file if not explicitly specified
         let globalVariables = {};
-        const globalsPath = path.resolve(options.globals);
+        let globalProcedures = {};
+        let globalsPath = path.resolve(options.globals);
+        // If default globals path doesn't exist, search up from first test file
+        if (!fs.existsSync(globalsPath) && options.globals === './globals.json' && files.length > 0) {
+            const testDir = path.dirname(files[0]);
+            globalsPath = findGlobalsFile(testDir) || globalsPath;
+        }
         if (fs.existsSync(globalsPath)) {
             try {
                 const globalsContent = fs.readFileSync(globalsPath, 'utf-8');
@@ -83,6 +104,9 @@ program
                 if (globals.variables && typeof globals.variables === 'object') {
                     globalVariables = globals.variables;
                 }
+                if (globals.procedures && typeof globals.procedures === 'object') {
+                    globalProcedures = globals.procedures;
+                }
             }
             catch (e) {
                 console.warn(`Warning: Could not load globals from ${globalsPath}: ${e.message}`);
@@ -111,6 +135,7 @@ program
             timeout: parseInt(options.timeout, 10),
             baseUrl: options.baseUrl,
             variables,
+            procedures: globalProcedures,
         };
         // Create reporter
         const reporter = createReporter(options.reporter, options.output);
@@ -248,7 +273,7 @@ program
                 'test:junit': 'testblocks run tests/**/*.testblocks.json -r junit -o reports',
             },
             devDependencies: {
-                '@testsmith/testblocks': '^0.5.0',
+                '@testsmith/testblocks': '^0.7.0',
             },
         };
         fs.writeFileSync(packagePath, JSON.stringify(packageJson, null, 2));
@@ -354,6 +379,56 @@ Thumbs.db
         fs.writeFileSync(gitignorePath, gitignore);
         console.log('  Created: .gitignore');
     }
+    // Create GitHub Actions workflow
+    const workflowDir = path.join(projectDir, '.github', 'workflows');
+    if (!fs.existsSync(workflowDir)) {
+        fs.mkdirSync(workflowDir, { recursive: true });
+        console.log('  Created: .github/workflows/');
+    }
+    const workflowPath = path.join(workflowDir, 'testblocks.yml');
+    if (!fs.existsSync(workflowPath)) {
+        const workflow = `name: TestBlocks Tests
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Install Playwright browsers
+        run: npx playwright install --with-deps chromium
+
+      - name: Run tests
+        run: npm test
+
+      - name: Upload test reports
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: test-reports
+          path: reports/
+          retention-days: 30
+`;
+        fs.writeFileSync(workflowPath, workflow);
+        console.log('  Created: .github/workflows/testblocks.yml');
+    }
     console.log('\n✓ Project initialized successfully!\n');
     console.log('Next steps:');
     console.log('  1. cd ' + (directory === '.' ? '' : directory));

package/dist/cli/reporters/ConsoleReporter.d.ts

@@ -0,0 +1,12 @@
+import { TestFile, TestResult } from '../../core';
+import { Reporter } from './types';
+/**
+ * Console reporter - outputs results to the terminal
+ */
+export declare class ConsoleReporter implements Reporter {
+    onTestFileComplete(file: string, testFile: TestFile, results: TestResult[]): void;
+    onComplete(allResults: {
+        file: string;
+        results: TestResult[];
+    }[]): void;
+}

package/dist/cli/reporters/ConsoleReporter.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleReporter = void 0;
+/**
+ * Console reporter - outputs results to the terminal
+ */
+class ConsoleReporter {
+    onTestFileComplete(file, testFile, results) {
+        console.log('');
+        for (const result of results) {
+            const icon = result.status === 'passed' ? '✓' : '✗';
+            const color = result.status === 'passed' ? '\x1b[32m' : '\x1b[31m';
+            const reset = '\x1b[0m';
+            console.log(`${color}  ${icon} ${result.testName}${reset} (${result.duration}ms)`);
+            if (result.error) {
+                console.log(`    ${result.error.message}`);
+            }
+        }
+        console.log('');
+    }
+    onComplete(allResults) {
+        const totalTests = allResults.reduce((sum, r) => sum + r.results.length, 0);
+        const passed = allResults.reduce((sum, r) => sum + r.results.filter(t => t.status === 'passed').length, 0);
+        const failed = allResults.reduce((sum, r) => sum + r.results.filter(t => t.status !== 'passed').length, 0);
+        const totalDuration = allResults.reduce((sum, r) => sum + r.results.reduce((s, t) => s + t.duration, 0), 0);
+        console.log('─'.repeat(50));
+        console.log(`Tests:       ${passed} passed, ${failed} failed, ${totalTests} total`);
+        console.log(`Duration:    ${(totalDuration / 1000).toFixed(2)}s`);
+        console.log(`Test Files:  ${allResults.length}`);
+        console.log('─'.repeat(50));
+        if (failed > 0) {
+            console.log('\n\x1b[31mTest run failed\x1b[0m\n');
+        }
+        else {
+            console.log('\n\x1b[32mAll tests passed!\x1b[0m\n');
+        }
+    }
+}
+exports.ConsoleReporter = ConsoleReporter;

package/dist/cli/reporters/HTMLReporter.d.ts

@@ -0,0 +1,19 @@
+import { TestFile, TestResult } from '../../core';
+import { Reporter, ReportData } from './types';
+/**
+ * HTML reporter - generates a styled HTML report
+ */
+export declare class HTMLReporter implements Reporter {
+    private outputDir;
+    private allResults;
+    constructor(outputDir: string);
+    onTestFileComplete(file: string, testFile: TestFile, results: TestResult[]): void;
+    onComplete(allResults: {
+        file: string;
+        results: TestResult[];
+    }[]): void;
+}
+/**
+ * Generate HTML report from report data
+ */
+export declare function generateHTMLReport(data: ReportData): string;