@testsmith/testblocks 0.8.0 → 0.8.2

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

@@ -97,6 +97,75 @@ function findPluginsDir(startDir) {
     }
     return null;
 }
+/**
+ * Load folder hooks from a test file's directory up to the root globals directory
+ * Returns hooks in order from outermost folder to innermost
+ */
+function loadFolderHooks(testFilePath, globalsDir) {
+    let currentDir = path.dirname(path.resolve(testFilePath));
+    const stopDir = globalsDir ? path.resolve(globalsDir) : null;
+    // Collect hooks from innermost to outermost
+    const collectedHooks = [];
+    while (currentDir) {
+        const hooksPath = path.join(currentDir, '_hooks.testblocks.json');
+        if (fs.existsSync(hooksPath)) {
+            try {
+                const content = fs.readFileSync(hooksPath, 'utf-8');
+                const hooksFile = JSON.parse(content);
+                collectedHooks.push(hooksFile);
+            }
+            catch (e) {
+                console.warn(`Warning: Could not load hooks from ${hooksPath}: ${e.message}`);
+            }
+        }
+        // Stop at globals directory or root
+        if (stopDir && currentDir === stopDir)
+            break;
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir)
+            break; // Reached root
+        currentDir = parentDir;
+    }
+    // Reverse to get outermost-to-innermost order
+    return collectedHooks.reverse();
+}
+/**
+ * Merge folder hooks into a test file
+ * - beforeAll/beforeEach: parent hooks run first
+ * - afterAll/afterEach: child hooks run first (reverse order)
+ */
+function mergeFolderHooksIntoTestFile(testFile, folderHooks) {
+    if (!folderHooks || folderHooks.length === 0) {
+        return testFile;
+    }
+    const beforeAllSteps = [];
+    const afterAllSteps = [];
+    const beforeEachSteps = [];
+    const afterEachSteps = [];
+    // Parent to child order for beforeAll/beforeEach
+    for (const hooks of folderHooks) {
+        if (hooks.beforeAll)
+            beforeAllSteps.push(...hooks.beforeAll);
+        if (hooks.beforeEach)
+            beforeEachSteps.push(...hooks.beforeEach);
+    }
+    // Child to parent order for afterAll/afterEach
+    for (let i = folderHooks.length - 1; i >= 0; i--) {
+        const hooks = folderHooks[i];
+        if (hooks.afterAll)
+            afterAllSteps.unshift(...hooks.afterAll);
+        if (hooks.afterEach)
+            afterEachSteps.unshift(...hooks.afterEach);
+    }
+    // Merge with test file hooks
+    return {
+        ...testFile,
+        beforeAll: [...beforeAllSteps, ...(testFile.beforeAll || [])],
+        afterAll: [...(testFile.afterAll || []), ...afterAllSteps],
+        beforeEach: [...beforeEachSteps, ...(testFile.beforeEach || [])],
+        afterEach: [...(testFile.afterEach || []), ...afterEachSteps],
+    };
+}
 const program = new commander_1.Command();
 program
     .name('testblocks')
@@ -212,9 +281,25 @@ 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);
+            let 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;
+            }
+            // Load and merge folder hooks
+            const globalsDir = fs.existsSync(globalsPath) ? path.dirname(globalsPath) : null;
+            const folderHooks = loadFolderHooks(file, globalsDir);
+            if (folderHooks.length > 0) {
+                testFile = mergeFolderHooksIntoTestFile(testFile, folderHooks);
+            }
             // Apply filter if specified
             if (options.filter) {
                 const filterRegex = new RegExp(options.filter, 'i');
@@ -266,7 +351,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);
@@ -277,7 +368,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) {
@@ -342,7 +434,7 @@ program
                 'test:junit': 'testblocks run tests/**/*.testblocks.json -r junit -o reports',
             },
             devDependencies: {
-                '@testsmith/testblocks': '^0.8.0',
+                '@testsmith/testblocks': '^0.8.2',
             },
         };
         fs.writeFileSync(packagePath, JSON.stringify(packageJson, null, 2));
@@ -522,9 +614,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.8.0",
+  "version": "0.8.2",
   "description": "Visual test automation tool with Blockly - API and Playwright testing",
   "author": "Roy de Kleijn",
   "license": "MIT",