@testsmith/testblocks 0.7.0 → 0.8.1

package/dist/cli/executor.d.ts

@@ -20,8 +20,8 @@ export declare class TestExecutor {
     private requiresBrowser;
     runTestFile(testFile: TestFile): Promise<TestResult[]>;
     private createBaseContext;
-    runTestWithData(test: TestCase, testFile: TestFile, dataSet: TestDataSet, dataIndex: number): Promise<TestResult>;
-    runTest(test: TestCase, testFile: TestFile): Promise<TestResult>;
+    runTestWithData(test: TestCase, testFile: TestFile, dataSet: TestDataSet, dataIndex: number, sharedVariables?: Map<string, unknown>): Promise<TestResult>;
+    runTest(test: TestCase, testFile: TestFile, sharedVariables?: Map<string, unknown>): Promise<TestResult>;
     private runSteps;
     private resolveVariableDefaults;
     private registerCustomBlocksFromProcedures;

package/dist/cli/executor.js

@@ -99,20 +99,20 @@ class TestExecutor {
                 const steps = this.extractStepsFromBlocklyState(testFile.beforeAll);
                 await this.runSteps(steps, baseContext, 'beforeAll');
             }
-            // Run each test
+            // Run each test - pass baseContext variables so beforeAll state persists
             for (const test of testFile.tests) {
                 // Check if test has data-driven sets
                 if (test.data && test.data.length > 0) {
                     // Run test for each data set
                     for (let i = 0; i < test.data.length; i++) {
                         const dataSet = test.data[i];
-                        const result = await this.runTestWithData(test, testFile, dataSet, i);
+                        const result = await this.runTestWithData(test, testFile, dataSet, i, baseContext.variables);
                         results.push(result);
                     }
                 }
                 else {
                     // Run test once without data
-                    const result = await this.runTest(test, testFile);
+                    const result = await this.runTest(test, testFile, baseContext.variables);
                     results.push(result);
                 }
             }
@@ -141,7 +141,7 @@ class TestExecutor {
             procedures: this.procedures,
         };
     }
-    async runTestWithData(test, testFile, dataSet, dataIndex) {
+    async runTestWithData(test, testFile, dataSet, dataIndex, sharedVariables) {
         const testName = dataSet.name
             ? `${test.name} [${dataSet.name}]`
             : `${test.name} [${dataIndex + 1}]`;
@@ -155,6 +155,17 @@ class TestExecutor {
             currentData: dataSet,
             dataIndex,
         };
+        // Merge shared variables from beforeAll (if any)
+        if (sharedVariables) {
+            for (const [key, value] of sharedVariables) {
+                if (!context.variables.has(key) || context.variables.get(key) === '' || context.variables.get(key) === undefined) {
+                    context.variables.set(key, value);
+                }
+                else if (key.startsWith('__')) {
+                    context.variables.set(key, value);
+                }
+            }
+        }
         // Inject data values into variables
         for (const [key, value] of Object.entries(dataSet.values)) {
             context.variables.set(key, value);
@@ -239,12 +250,25 @@ class TestExecutor {
             },
         };
     }
-    async runTest(test, testFile) {
+    async runTest(test, testFile, sharedVariables) {
         console.log(`  Running: ${test.name}`);
         const startedAt = new Date().toISOString();
         const startTime = Date.now();
         const stepResults = [];
         const context = this.createBaseContext(testFile.variables);
+        // Merge shared variables from beforeAll (if any)
+        if (sharedVariables) {
+            for (const [key, value] of sharedVariables) {
+                // Only copy if not already set (don't override file-level defaults)
+                if (!context.variables.has(key) || context.variables.get(key) === '' || context.variables.get(key) === undefined) {
+                    context.variables.set(key, value);
+                }
+                else if (key.startsWith('__')) {
+                    // Always copy internal state variables like __requestHeaders
+                    context.variables.set(key, value);
+                }
+            }
+        }
         for (const plugin of this.plugins.values()) {
             if (plugin.hooks?.beforeTest) {
                 await plugin.hooks.beforeTest(context, test);

package/dist/cli/index.js

@@ -41,6 +41,32 @@ const glob_1 = require("glob");
 const executor_1 = require("./executor");
 const reporters_1 = require("./reporters");
 const startServer_1 = require("../server/startServer");
+const plugins_1 = require("../server/plugins");
+const globals_1 = require("../server/globals");
+/**
+ * Get the package version from package.json
+ */
+function getVersion() {
+    try {
+        // Try to find package.json relative to the compiled CLI
+        const possiblePaths = [
+            path.join(__dirname, '../../package.json'), // dist/cli -> package.json
+            path.join(__dirname, '../../../package.json'), // nested node_modules
+        ];
+        for (const pkgPath of possiblePaths) {
+            if (fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                if (pkg.name === '@testsmith/testblocks' && pkg.version) {
+                    return pkg.version;
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return '0.0.0';
+}
 /**
  * Search up the directory tree for globals.json starting from the given directory
  */
@@ -56,11 +82,26 @@ function findGlobalsFile(startDir) {
     }
     return null;
 }
+/**
+ * Search up the directory tree for a plugins directory starting from the given directory
+ */
+function findPluginsDir(startDir) {
+    let currentDir = path.resolve(startDir);
+    const root = path.parse(currentDir).root;
+    while (currentDir !== root) {
+        const pluginsPath = path.join(currentDir, 'plugins');
+        if (fs.existsSync(pluginsPath) && fs.statSync(pluginsPath).isDirectory()) {
+            return pluginsPath;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
 const program = new commander_1.Command();
 program
     .name('testblocks')
     .description('CLI runner for TestBlocks visual test automation')
-    .version('1.0.0');
+    .version(getVersion());
 program
     .command('run')
     .description('Run test files')
@@ -72,6 +113,7 @@ program
     .option('-b, --base-url <url>', 'Base URL for relative URLs')
     .option('-v, --var <vars...>', 'Variables in key=value format')
     .option('-g, --globals <path>', 'Path to globals.json file', './globals.json')
+    .option('--plugins-dir <dir>', 'Plugins directory (auto-discovered if not specified)')
     .option('--fail-fast', 'Stop on first test failure', false)
     .option('-p, --parallel <count>', 'Number of parallel workers', '1')
     .option('--filter <pattern>', 'Only run tests matching pattern')
@@ -112,6 +154,33 @@ program
                 console.warn(`Warning: Could not load globals from ${globalsPath}: ${e.message}`);
             }
         }
+        // Load plugins - search up directory tree from first test file if not explicitly specified
+        let pluginsDir = options.pluginsDir ? path.resolve(options.pluginsDir) : null;
+        // If plugins dir not specified, auto-discover from test file location or globals location
+        if (!pluginsDir && files.length > 0) {
+            const testDir = path.dirname(files[0]);
+            pluginsDir = findPluginsDir(testDir);
+        }
+        // Also check next to globals.json if still not found
+        if (!pluginsDir && fs.existsSync(globalsPath)) {
+            const globalsDir = path.dirname(globalsPath);
+            const pluginsDirNextToGlobals = path.join(globalsDir, 'plugins');
+            if (fs.existsSync(pluginsDirNextToGlobals) && fs.statSync(pluginsDirNextToGlobals).isDirectory()) {
+                pluginsDir = pluginsDirNextToGlobals;
+            }
+        }
+        // Load plugins if directory found
+        if (pluginsDir && fs.existsSync(pluginsDir)) {
+            (0, plugins_1.setPluginsDirectory)(pluginsDir);
+            await (0, plugins_1.loadAllPlugins)();
+            (0, plugins_1.initializeServerPlugins)();
+        }
+        // Load snippets from the globals directory (snippets/ folder next to globals.json)
+        if (fs.existsSync(globalsPath)) {
+            const globalsDir = path.dirname(globalsPath);
+            (0, globals_1.setGlobalsDirectory)(globalsDir);
+            (0, globals_1.loadAllSnippets)();
+        }
         // Parse CLI variables (these override globals)
         const cliVariables = {};
         if (options.var) {
@@ -143,9 +212,19 @@ program
         const allResults = [];
         let hasFailures = false;
         for (const file of files) {
-            console.log(`Running: ${path.basename(file)}`);
+            // Skip _hooks.testblocks.json files - these are folder hooks, not test files
+            const basename = path.basename(file);
+            if (basename === '_hooks.testblocks.json') {
+                continue;
+            }
+            console.log(`Running: ${basename}`);
             const content = fs.readFileSync(file, 'utf-8');
             const testFile = JSON.parse(content);
+            // Skip files that have no tests array (e.g., hooks-only files)
+            if (!testFile.tests || !Array.isArray(testFile.tests)) {
+                console.log('  (no tests in file)\n');
+                continue;
+            }
             // Apply filter if specified
             if (options.filter) {
                 const filterRegex = new RegExp(options.filter, 'i');
@@ -197,7 +276,13 @@ program
         }
         let hasErrors = false;
         for (const file of files) {
-            console.log(`Validating: ${path.basename(file)}`);
+            const basename = path.basename(file);
+            // Skip _hooks.testblocks.json files from validation (they're hooks, not test files)
+            if (basename === '_hooks.testblocks.json') {
+                console.log(`Skipping: ${basename} (folder hooks file)`);
+                continue;
+            }
+            console.log(`Validating: ${basename}`);
             try {
                 const content = fs.readFileSync(file, 'utf-8');
                 const testFile = JSON.parse(content);
@@ -208,7 +293,8 @@ program
                     errors.forEach(err => console.log(`    - ${err}`));
                 }
                 else {
-                    console.log(`  ✓ Valid (${testFile.tests.length} tests)`);
+                    const testCount = testFile.tests?.length || 0;
+                    console.log(`  ✓ Valid (${testCount} tests)`);
                 }
             }
             catch (error) {
@@ -273,7 +359,7 @@ program
                 'test:junit': 'testblocks run tests/**/*.testblocks.json -r junit -o reports',
             },
             devDependencies: {
-                '@testsmith/testblocks': '^0.7.0',
+                '@testsmith/testblocks': '^0.8.1',
             },
         };
         fs.writeFileSync(packagePath, JSON.stringify(packageJson, null, 2));
@@ -453,9 +539,18 @@ program
             process.exit(1);
         }
         for (const file of files) {
-            console.log(`\n${path.basename(file)}:`);
+            // Skip _hooks.testblocks.json files
+            const basename = path.basename(file);
+            if (basename === '_hooks.testblocks.json') {
+                continue;
+            }
+            console.log(`\n${basename}:`);
             const content = fs.readFileSync(file, 'utf-8');
             const testFile = JSON.parse(content);
+            if (!testFile.tests || !Array.isArray(testFile.tests)) {
+                console.log('  (no tests in file)');
+                continue;
+            }
             testFile.tests.forEach((test, index) => {
                 const tags = test.tags?.length ? ` [${test.tags.join(', ')}]` : '';
                 console.log(`  ${index + 1}. ${test.name}${tags}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testsmith/testblocks",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Visual test automation tool with Blockly - API and Playwright testing",
   "author": "Roy de Kleijn",
   "license": "MIT",