@testsmith/testblocks 0.6.0 → 0.8.0

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

@@ -0,0 +1,14 @@
+import { Logger } from '../types';
+export interface LoggerOptions {
+    prefix?: string;
+    indent?: string;
+    debug?: boolean;
+}
+/**
+ * Create a logger instance for test execution
+ */
+export declare function createLogger(options?: LoggerOptions): Logger;
+/**
+ * Create a CLI-style logger with simpler output
+ */
+export declare function createCliLogger(): Logger;

package/dist/core/utils/logger.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+exports.createCliLogger = createCliLogger;
+/**
+ * Create a logger instance for test execution
+ */
+function createLogger(options = {}) {
+    const { prefix = '', indent = '    ', debug = false } = options;
+    const logPrefix = prefix ? `${prefix} ` : '';
+    return {
+        info: (message, data) => {
+            console.log(`${indent}[INFO] ${logPrefix}${message}`, data !== undefined ? data : '');
+        },
+        warn: (message, data) => {
+            console.warn(`${indent}[WARN] ${logPrefix}${message}`, data !== undefined ? data : '');
+        },
+        error: (message, data) => {
+            console.error(`${indent}[ERROR] ${logPrefix}${message}`, data !== undefined ? data : '');
+        },
+        debug: (message, data) => {
+            if (debug || process.env.DEBUG) {
+                console.debug(`${indent}[DEBUG] ${logPrefix}${message}`, data !== undefined ? data : '');
+            }
+        },
+    };
+}
+/**
+ * Create a CLI-style logger with simpler output
+ */
+function createCliLogger() {
+    return {
+        info: (message, data) => {
+            console.log(`    ${message}`, data !== undefined ? data : '');
+        },
+        warn: (message, data) => {
+            console.warn(`    \u26a0 ${message}`, data !== undefined ? data : '');
+        },
+        error: (message, data) => {
+            console.error(`    \u2717 ${message}`, data !== undefined ? data : '');
+        },
+        debug: (message, data) => {
+            if (process.env.DEBUG) {
+                console.debug(`    [debug] ${message}`, data !== undefined ? data : '');
+            }
+        },
+    };
+}

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

@@ -0,0 +1,24 @@
+import { ExecutionContext } from '../types';
+/**
+ * Utility class for resolving variable placeholders in strings
+ */
+export declare class VariableResolver {
+    /**
+     * Resolve ${variable} placeholders in a string using context variables and currentData
+     * Supports dot notation for nested object access (e.g., ${user.email})
+     */
+    static resolve(text: string, context: ExecutionContext): string;
+    /**
+     * Resolve variables in an object recursively
+     */
+    static resolveObject(obj: unknown, context: ExecutionContext): unknown;
+    /**
+     * Check if a string contains variable placeholders
+     */
+    static hasVariables(text: string): boolean;
+}
+/**
+ * Resolve variable defaults from globals format
+ * Handles objects with { type, default, description } structure
+ */
+export declare function resolveVariableDefaults(vars?: Record<string, unknown>): Record<string, unknown>;

package/dist/core/utils/variableResolver.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableResolver = void 0;
+exports.resolveVariableDefaults = resolveVariableDefaults;
+/**
+ * Utility class for resolving variable placeholders in strings
+ */
+class VariableResolver {
+    /**
+     * Resolve ${variable} placeholders in a string using context variables and currentData
+     * Supports dot notation for nested object access (e.g., ${user.email})
+     */
+    static resolve(text, context) {
+        if (typeof text !== 'string')
+            return text;
+        return text.replace(/\$\{([\w.]+)\}/g, (match, path) => {
+            const parts = path.split('.');
+            const varName = parts[0];
+            // Check currentData first (for data-driven tests)
+            if (context.currentData?.values[varName] !== undefined) {
+                let value = context.currentData.values[varName];
+                // Handle dot notation for nested access
+                if (parts.length > 1 && value !== null && typeof value === 'object') {
+                    for (let i = 1; i < parts.length; i++) {
+                        if (value === undefined || value === null)
+                            break;
+                        value = value[parts[i]];
+                    }
+                }
+                if (value !== undefined && value !== null) {
+                    return typeof value === 'object' ? JSON.stringify(value) : String(value);
+                }
+            }
+            // Then check context variables
+            let value = context.variables.get(varName);
+            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;
+            return typeof value === 'object' ? JSON.stringify(value) : String(value);
+        });
+    }
+    /**
+     * Resolve variables in an object recursively
+     */
+    static resolveObject(obj, context) {
+        if (typeof obj === 'string') {
+            return this.resolve(obj, context);
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(item => this.resolveObject(item, context));
+        }
+        if (obj && typeof obj === 'object') {
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                result[key] = this.resolveObject(value, context);
+            }
+            return result;
+        }
+        return obj;
+    }
+    /**
+     * Check if a string contains variable placeholders
+     */
+    static hasVariables(text) {
+        return typeof text === 'string' && /\$\{[\w.]+\}/.test(text);
+    }
+}
+exports.VariableResolver = VariableResolver;
+/**
+ * Resolve variable defaults from globals format
+ * Handles objects with { type, default, description } structure
+ */
+function resolveVariableDefaults(vars) {
+    if (!vars)
+        return {};
+    const resolved = {};
+    for (const [key, value] of Object.entries(vars)) {
+        if (value && typeof value === 'object' && 'default' in value) {
+            resolved[key] = value.default;
+        }
+        else {
+            resolved[key] = value;
+        }
+    }
+    return resolved;
+}

package/dist/server/executor.d.ts

@@ -7,6 +7,7 @@ export interface ExecutorOptions {
     plugins?: Plugin[];
     testIdAttribute?: string;
     baseDir?: string;
+    procedures?: Record<string, ProcedureDefinition>;
 }
 export declare class TestExecutor {
     private options;
@@ -14,6 +15,7 @@ export declare class TestExecutor {
     private context;
     private page;
     private plugins;
+    private projectProcedures;
     constructor(options?: ExecutorOptions);
     initialize(): Promise<void>;
     cleanup(): Promise<void>;
@@ -34,5 +36,9 @@ export declare class TestExecutor {
     private resolveParams;
     private loadDataFromFile;
     private resolveVariableDefaults;
+    /**
+     * Resolve ${variable} placeholders in a string using context variables and currentData
+     */
+    private static resolveVariablePlaceholders;
     private createLogger;
 }

package/dist/server/executor.js

@@ -93,6 +93,7 @@ class TestExecutor {
         this.context = null;
         this.page = null;
         this.plugins = new Map();
+        this.projectProcedures = new Map();
         this.options = {
             headless: true,
             timeout: 30000,
@@ -104,6 +105,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.projectProcedures.set(name, procedure);
+            }
+            this.registerCustomBlocksFromProcedures(options.procedures);
+        }
     }
     async initialize() {
         // Set the test ID attribute globally for Playwright selectors
@@ -169,10 +177,17 @@ class TestExecutor {
             await this.initialize();
         }
         // Create shared execution context for lifecycle hooks
+        // Merge project-level and file-level procedures (file takes precedence)
+        const mergedProcedures = new Map(this.projectProcedures);
+        if (testFile.procedures) {
+            for (const [name, proc] of Object.entries(testFile.procedures)) {
+                mergedProcedures.set(name, proc);
+            }
+        }
         const sharedContext = {
             variables: new Map(Object.entries({
                 ...this.resolveVariableDefaults(testFile.variables),
-                ...this.options.variables,
+                ...this.resolveVariableDefaults(this.options.variables),
             })),
             results: [],
             browser: this.browser,
@@ -180,7 +195,9 @@ class TestExecutor {
             logger: this.createLogger(),
             plugins: this.plugins,
             testIdAttribute: this.options.testIdAttribute,
+            procedures: mergedProcedures,
         };
+        let beforeAllFailed = false;
         try {
             // Run beforeAll hooks
             if (testFile.beforeAll && testFile.beforeAll.length > 0) {
@@ -188,29 +205,49 @@ class TestExecutor {
                 const beforeAllResult = await this.runLifecycleSteps(testFile.beforeAll, 'beforeAll', sharedContext);
                 results.push(beforeAllResult);
                 if (beforeAllResult.status === 'failed' || beforeAllResult.status === 'error') {
-                    // Don't run tests if beforeAll failed
-                    return results;
+                    // Don't run tests if beforeAll failed, but still run afterAll
+                    beforeAllFailed = true;
                 }
             }
-            // Run each test with beforeEach/afterEach
-            for (const test of testFile.tests) {
-                // Load data from file if specified
-                let testData = test.data;
-                if (test.dataFile && !testData) {
-                    testData = this.loadDataFromFile(test.dataFile);
-                }
-                // Check if test has data-driven sets
-                if (testData && testData.length > 0) {
-                    // Run test for each data set
-                    for (let i = 0; i < testData.length; i++) {
-                        const dataSet = testData[i];
+            // Only run tests if beforeAll succeeded
+            if (!beforeAllFailed) {
+                // Run each test with beforeEach/afterEach
+                for (const test of testFile.tests) {
+                    // Load data from file if specified
+                    let testData = test.data;
+                    if (test.dataFile && !testData) {
+                        testData = this.loadDataFromFile(test.dataFile);
+                    }
+                    // Check if test has data-driven sets
+                    if (testData && testData.length > 0) {
+                        // Run test for each data set
+                        for (let i = 0; i < testData.length; i++) {
+                            const dataSet = testData[i];
+                            // Run suite-level beforeEach
+                            if (testFile.beforeEach && testFile.beforeEach.length > 0) {
+                                for (const step of testFile.beforeEach) {
+                                    await this.runStep(step, sharedContext);
+                                }
+                            }
+                            const result = await this.runTestWithData(test, testFile.variables, dataSet, i, sharedContext);
+                            results.push(result);
+                            // Run suite-level afterEach
+                            if (testFile.afterEach && testFile.afterEach.length > 0) {
+                                for (const step of testFile.afterEach) {
+                                    await this.runStep(step, sharedContext);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // Run test once without data
                         // Run suite-level beforeEach
                         if (testFile.beforeEach && testFile.beforeEach.length > 0) {
                             for (const step of testFile.beforeEach) {
                                 await this.runStep(step, sharedContext);
                             }
                         }
-                        const result = await this.runTestWithData(test, testFile.variables, dataSet, i, sharedContext);
+                        const result = await this.runTest(test, testFile.variables, sharedContext);
                         results.push(result);
                         // Run suite-level afterEach
                         if (testFile.afterEach && testFile.afterEach.length > 0) {
@@ -220,32 +257,37 @@ class TestExecutor {
                         }
                     }
                 }
-                else {
-                    // Run test once without data
-                    // Run suite-level beforeEach
-                    if (testFile.beforeEach && testFile.beforeEach.length > 0) {
-                        for (const step of testFile.beforeEach) {
-                            await this.runStep(step, sharedContext);
-                        }
-                    }
-                    const result = await this.runTest(test, testFile.variables, sharedContext);
-                    results.push(result);
-                    // Run suite-level afterEach
-                    if (testFile.afterEach && testFile.afterEach.length > 0) {
-                        for (const step of testFile.afterEach) {
-                            await this.runStep(step, sharedContext);
-                        }
-                    }
-                }
             }
-            // Run afterAll hooks
+        }
+        finally {
+            // Always run afterAll hooks, even if beforeAll failed
+            // This ensures cleanup happens regardless of setup failures
             if (testFile.afterAll && testFile.afterAll.length > 0) {
                 sharedContext.logger.info('Running afterAll hooks...');
-                const afterAllResult = await this.runLifecycleSteps(testFile.afterAll, 'afterAll', sharedContext);
-                results.push(afterAllResult);
+                try {
+                    const afterAllResult = await this.runLifecycleSteps(testFile.afterAll, 'afterAll', sharedContext);
+                    results.push(afterAllResult);
+                }
+                catch (afterAllError) {
+                    // Log but don't throw - we still want cleanup to complete
+                    sharedContext.logger.error('afterAll hook failed', afterAllError.message);
+                    results.push({
+                        testId: 'lifecycle-afterAll',
+                        testName: 'afterAll',
+                        status: 'error',
+                        duration: 0,
+                        steps: [],
+                        error: {
+                            message: afterAllError.message,
+                            stack: afterAllError.stack,
+                        },
+                        startedAt: new Date().toISOString(),
+                        finishedAt: new Date().toISOString(),
+                        isLifecycle: true,
+                        lifecycleType: 'afterAll',
+                    });
+                }
             }
-        }
-        finally {
             await this.cleanup();
         }
         return results;
@@ -285,7 +327,9 @@ class TestExecutor {
         this.registerCustomBlocksFromProcedures(procedures);
     }
     registerCustomBlocksFromProcedures(procedures) {
-        Object.values(procedures).forEach(proc => {
+        Object.entries(procedures).forEach(([name, proc]) => {
+            // Register in the procedure registry so getProcedure() can find it
+            (0, core_1.registerProcedure)(name, proc);
             if (!proc.steps || proc.steps.length === 0)
                 return;
             const blockType = `custom_${proc.name.toLowerCase().replace(/\s+/g, '_')}`;
@@ -308,10 +352,20 @@ class TestExecutor {
                 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 value = params[p.name.toUpperCase()];
+                        const paramKey = p.name.toUpperCase();
+                        let value = params[paramKey];
                         if (value !== undefined) {
+                            // Resolve variable placeholders like ${email} from context/currentData
+                            if (typeof value === 'string') {
+                                value = TestExecutor.resolveVariablePlaceholders(value, context);
+                            }
                             context.variables.set(p.name, value);
+                            context.logger.debug(`Set procedure param: ${p.name} = "${value}"`);
+                        }
+                        else {
+                            context.logger.warn(`Procedure param not found in params: ${paramKey} (available: ${Object.keys(params).join(', ')})`);
                         }
                     });
                     return {
@@ -333,7 +387,7 @@ class TestExecutor {
             ? Object.fromEntries(sharedContext.variables)
             : {
                 ...this.resolveVariableDefaults(fileVariables),
-                ...this.options.variables,
+                ...this.resolveVariableDefaults(this.options.variables),
             };
         const context = {
             variables: new Map(Object.entries(baseVariables)),
@@ -343,6 +397,11 @@ class TestExecutor {
             logger: this.createLogger(),
             plugins: this.plugins,
             testIdAttribute: this.options.testIdAttribute,
+            // Inherit procedures from shared context
+            procedures: sharedContext?.procedures || new Map(),
+            // Enable soft assertions if configured on the test
+            softAssertions: test.softAssertions || false,
+            softAssertionErrors: [],
         };
         // Run beforeTest hooks
         for (const plugin of this.plugins.values()) {
@@ -352,6 +411,7 @@ class TestExecutor {
         }
         let testStatus = 'passed';
         let testError;
+        let collectedSoftErrors = [];
         try {
             // Execute steps from Blockly serialization format
             const steps = this.extractStepsFromBlocklyState(test.steps);
@@ -361,9 +421,21 @@ class TestExecutor {
                 if (stepResult.status === 'failed' || stepResult.status === 'error') {
                     testStatus = stepResult.status;
                     testError = stepResult.error;
-                    break;
+                    // In soft assertion mode, continue executing remaining steps
+                    if (!context.softAssertions) {
+                        break;
+                    }
                 }
             }
+            // Check for soft assertion errors at the end of the test
+            collectedSoftErrors = context.softAssertionErrors || [];
+            if (collectedSoftErrors.length > 0 && testStatus === 'passed') {
+                testStatus = 'failed';
+                const errorMessages = collectedSoftErrors.map((e, i) => `  ${i + 1}. ${e.message}`).join('\n');
+                testError = {
+                    message: `${collectedSoftErrors.length} soft assertion(s) failed:\n${errorMessages}`,
+                };
+            }
         }
         catch (error) {
             testStatus = 'error';
@@ -381,6 +453,7 @@ class TestExecutor {
             error: testError,
             startedAt,
             finishedAt: new Date().toISOString(),
+            softAssertionErrors: collectedSoftErrors.length > 0 ? collectedSoftErrors : undefined,
         };
         // Run afterTest hooks
         for (const plugin of this.plugins.values()) {
@@ -403,7 +476,7 @@ class TestExecutor {
             ? Object.fromEntries(sharedContext.variables)
             : {
                 ...this.resolveVariableDefaults(fileVariables),
-                ...this.options.variables,
+                ...this.resolveVariableDefaults(this.options.variables),
             };
         const context = {
             variables: new Map(Object.entries(baseVariables)),
@@ -413,8 +486,13 @@ class TestExecutor {
             logger: this.createLogger(),
             plugins: this.plugins,
             testIdAttribute: this.options.testIdAttribute,
+            // Inherit procedures from shared context
+            procedures: sharedContext?.procedures || new Map(),
             currentData: dataSet,
             dataIndex,
+            // Enable soft assertions if configured on the test
+            softAssertions: test.softAssertions || false,
+            softAssertionErrors: [],
         };
         // Inject data values into variables
         for (const [key, value] of Object.entries(dataSet.values)) {
@@ -428,6 +506,7 @@ class TestExecutor {
         }
         let testStatus = 'passed';
         let testError;
+        let collectedSoftErrors = [];
         try {
             // Execute steps from Blockly serialization format
             const steps = this.extractStepsFromBlocklyState(test.steps);
@@ -437,9 +516,21 @@ class TestExecutor {
                 if (stepResult.status === 'failed' || stepResult.status === 'error') {
                     testStatus = stepResult.status;
                     testError = stepResult.error;
-                    break;
+                    // In soft assertion mode, continue executing remaining steps
+                    if (!context.softAssertions) {
+                        break;
+                    }
                 }
             }
+            // Check for soft assertion errors at the end of the test
+            collectedSoftErrors = context.softAssertionErrors || [];
+            if (collectedSoftErrors.length > 0 && testStatus === 'passed') {
+                testStatus = 'failed';
+                const errorMessages = collectedSoftErrors.map((e, i) => `  ${i + 1}. ${e.message}`).join('\n');
+                testError = {
+                    message: `${collectedSoftErrors.length} soft assertion(s) failed:\n${errorMessages}`,
+                };
+            }
         }
         catch (error) {
             testStatus = 'error';
@@ -457,6 +548,7 @@ class TestExecutor {
             error: testError,
             startedAt,
             finishedAt: new Date().toISOString(),
+            softAssertionErrors: collectedSoftErrors.length > 0 ? collectedSoftErrors : undefined,
         };
         // Run afterTest hooks
         for (const plugin of this.plugins.values()) {
@@ -577,6 +669,29 @@ class TestExecutor {
                     }
                 }
             }
+            // Handle procedure calls (procedure_call block)
+            if (output && typeof output === 'object' && 'procedureCall' in output) {
+                const procOutput = output;
+                // Set procedure arguments as variables (resolve any ${var} placeholders first)
+                for (const [argName, argValue] of Object.entries(procOutput.args)) {
+                    let resolvedValue = argValue;
+                    if (typeof argValue === 'string') {
+                        resolvedValue = TestExecutor.resolveVariablePlaceholders(argValue, context);
+                    }
+                    context.variables.set(argName, resolvedValue);
+                }
+                // Run the procedure's steps
+                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';
@@ -618,13 +733,20 @@ class TestExecutor {
     async resolveParams(params, context) {
         const resolved = {};
         for (const [key, value] of Object.entries(params)) {
-            if (value && typeof value === 'object' && 'type' in value) {
-                // This is a connected block - execute it to get the value
+            if (value && typeof value === 'object' && 'type' in value && 'id' in value) {
+                // This is a connected block (has both 'type' and 'id') - execute it to get the value
                 const nestedStep = value;
                 const blockDef = (0, core_1.getBlock)(nestedStep.type);
                 if (blockDef) {
                     const nestedParams = await this.resolveParams(nestedStep.params || {}, context);
-                    resolved[key] = await blockDef.execute(nestedParams, context);
+                    const result = await blockDef.execute(nestedParams, context);
+                    // Value blocks return { _value: actualValue, ... } - extract the actual value
+                    if (result && typeof result === 'object' && '_value' in result) {
+                        resolved[key] = result._value;
+                    }
+                    else {
+                        resolved[key] = result;
+                    }
                 }
             }
             else {
@@ -683,6 +805,44 @@ class TestExecutor {
         }
         return resolved;
     }
+    /**
+     * Resolve ${variable} placeholders in a string using context variables and currentData
+     */
+    static resolveVariablePlaceholders(text, context) {
+        if (typeof text !== 'string')
+            return text;
+        return text.replace(/\$\{([\w.]+)\}/g, (match, path) => {
+            const parts = path.split('.');
+            const varName = parts[0];
+            // Check currentData first (for data-driven tests)
+            if (context.currentData?.values[varName] !== undefined) {
+                let value = context.currentData.values[varName];
+                // Handle dot notation for nested access
+                if (parts.length > 1 && value !== null && typeof value === 'object') {
+                    for (let i = 1; i < parts.length; i++) {
+                        if (value === undefined || value === null)
+                            break;
+                        value = value[parts[i]];
+                    }
+                }
+                if (value !== undefined && value !== null) {
+                    return typeof value === 'object' ? JSON.stringify(value) : String(value);
+                }
+            }
+            // Then check context variables
+            let value = context.variables.get(varName);
+            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;
+            return typeof value === 'object' ? JSON.stringify(value) : String(value);
+        });
+    }
     createLogger() {
         return {
             info: (message, data) => {

package/dist/server/globals.d.ts

@@ -5,9 +5,10 @@
  * - globals.json - Shared variables across all test files
  * - snippets/ - Reusable block sequences (composite blocks)
  */
-import { TestStep } from '../core';
+import { TestStep, ProcedureDefinition } from '../core';
 export interface GlobalsConfig {
     variables?: Record<string, unknown>;
+    procedures?: Record<string, ProcedureDefinition>;
     baseUrl?: string;
     timeout?: number;
     testIdAttribute?: string;
@@ -47,6 +48,10 @@ export declare function getGlobals(): GlobalsConfig;
  * Get global variables
  */
 export declare function getGlobalVariables(): Record<string, unknown>;
+/**
+ * Get global procedures from globals.json
+ */
+export declare function getGlobalProcedures(): Record<string, ProcedureDefinition>;
 /**
  * Get the configured test ID attribute (defaults to 'data-testid')
  */

package/dist/server/globals.js

@@ -45,6 +45,7 @@ exports.getGlobalsDirectory = getGlobalsDirectory;
 exports.loadGlobals = loadGlobals;
 exports.getGlobals = getGlobals;
 exports.getGlobalVariables = getGlobalVariables;
+exports.getGlobalProcedures = getGlobalProcedures;
 exports.getTestIdAttribute = getTestIdAttribute;
 exports.setTestIdAttribute = setTestIdAttribute;
 exports.discoverSnippets = discoverSnippets;
@@ -105,6 +106,12 @@ function getGlobals() {
 function getGlobalVariables() {
     return loadedGlobals.variables || {};
 }
+/**
+ * Get global procedures from globals.json
+ */
+function getGlobalProcedures() {
+    return loadedGlobals.procedures || {};
+}
 /**
  * Get the configured test ID attribute (defaults to 'data-testid')
  */