Test Bench

The Test Bench is a built-in testing environment that allows you to evaluate and validate your rules before deploying them to production. By entering input data and simulating rule execution, you can verify that your rules produce the expected outputs and identify any issues early in the development process.

In this guideline you need to have knowledge of Decision Table and Decision Tree.

Why Use Test Bench

• Validate logic - Ensure rules work correctly before deployment.

• Test edge cases - Verify behavior with different input scenarios.

• Debug issues - Identify and fix problems during development with Debug Mode.

• View detailed execution - See exactly which rows or branches executed.

• Iterate quickly - Make changes and test immediately.

Accessing Test Bench

Test Bench is available for all rule types and provides a consistent testing experience across them.

To open Test Bench:

1. Navigate to any rule in the designer.

2. Click to open the Test Bench in the bottom bar.

Test Bench Modes

Test Bench offers two interface modes to accommodate different user preferences and use cases:

1. Simple Bench

A simplified interface that displays input (left side of bench) and output (right side of bench) fields as individual form fields, making it easy to test rules without JSON knowledge.

Best for:

• Users unfamiliar with JSON.

• Quick testing with simple inputs.

• Clear visualization of individual fields.

Commas create arrays (e.g., 1,2,3 becomes [1, 2, 3]). To use a comma inside a value, wrap it in quotes: "some,text".

Date Input in Simple Bench

Simple Bench provides a convenient date picker for date fields:

1. Click the three dots next to the field.

2. Click the calendar icon.

1. Select:

   • Date (day, month, year)

   • Time (hours, minutes)

   • Time zone

1. Click Save.

2. JSON Bench

A JSON editor interface for entering input and viewing output in standard JSON format.

Best for:

• Technical users comfortable with JSON.

• Complex nested data structures.

• Arrays of objects.

• Copy/paste from API responses.

• Precise control over data structure.

Switching Between Modes

Data Persistence:

• Input data is preserved when switching between Simple and JSON Bench.

• You won't lose your test data when changing views.

Understanding Display Limitations in Simple Bench

While Simple Bench is convenient for basic testing, it has limitations when handling complex nested structures. Here are important behaviors to be aware of:

1. Objects Without Defined Children

If your input model defines a parent object without specifying its children structure (as an empty object {}), and you provide actual nested data in JSON Bench, Simple Bench will display this as [object Object].

// Input Model

{
  "action": {
    "transaction": {}  // Empty object - no children defined
  }
}

// Actual JSON Input

{
  "action": {
    "transaction": { // last children based on input model
      "transactionValue": 10000,
      "transactionCurrency": "USD",
      "transactionValueEurEquivalent": 9500
    }
  }
}

// Simple Bench Display:
action.transaction: [object Object]

What this means:

• The model doesn't define what children transaction should have.

• Simple Bench can't break it down into individual fields.

• Display shows [object Object] as a placeholder.

It still works:

• The rule receives and processes the complete nested data correctly.

• This is only a display limitation in Simple Bench.

• Use JSON Bench to see and edit the full structure.

1. Arrays of Objects

Arrays of objects behave differently depending on whether they're in input or output fields.

• Input Fields: Not Practical in Simple Bench. Arrays of objects in input fields display as [object Object], [object Object], [object Object]..., which doesn't allow you to see or edit the actual data.

// Input Model

{
  "factorList": {} // Empty object - no children defined
}

// Actual JSON Input
{
  "factorList": [
    { "destinationRisk": 0, "historyRisk": 0 },
    { "destinationRisk": 1000, "historyRisk": 1000 }
  ]
}

// Simple Bench Display:
factorList: [object Object], [object Object]

Use JSON Bench for inputs containing arrays of objects.

• Output Fields: Arrays of objects in output fields show a View button that opens a detail modal.

// Output Model

{
  "factorList": {} // Empty object - no children defined
}

// Actual JSON Output
{
  "factorList": [
    { "destinationRisk": 0, "historyRisk": 0 },
    { "destinationRisk": 1000, "historyRisk": 1000 }
  ]
}

// Simple Bench Display:
factorList: View

Viewing Details:

1. Click the View button

2. A Detail View modal opens

3. See the complete structure:

   • Each array element numbered (0, 1, 2...)

   • All properties displayed with formatting

   • Collapsible structure for navigation

Execution Modes

Test Bench supports different execution modes depending on the rule type and your testing needs. For detailed information about execution strategies and modes, see Execution Strategy.

Debug Mode

Debug Mode provides detailed execution information, helping you understand exactly how your rule processes data and where issues might occur.

Debug Mode is available for Decision Tables and Decision Trees only.

How to Enable Debug Mode

1. Open Test Bench.

2. Look for the Debug toggle/checkbox.

3. Enable it (toggle to ON/checked state).

4. Click Run to execute with debug information.

Debug Decision Table

When Debug Mode is enabled for Decision Table, you get detailed visual feedback showing exactly how your input data matches against each condition.

Visual Indicators

Row Highlighting:

• The executed row(s) are visually highlighted in the table.

Shows which rows matched your input conditions.

Cell-Level Feedback:

• Green cells - Condition passed (evaluated to true).

• Red cells - Condition failed (evaluated to false).

This allows you to see exactly which condition caused a row to pass or fail.

Value Display:

• Each condition cell shows the actual value being compared.

You can see what the rule is evaluating against your input.

Rows 6 and 11 were executed successfully.

Debug Decision Tree

When Debug Mode is enabled for Decision Trees, you can trace the execution path through the tree structure and see exactly which conditions were evaluated and which branch was taken.

Visual Indicators

Block Highlighting:

• Colored borders show which nodes were evaluated during execution.

• Green-highlighted blocks indicate the path that was taken and executed.

• Red-highlighted blocks indicate the path that was not taken.

Shows the decision flow from top to bottom through your tree.

Value Display:

• Condition blocks show the actual values being compared.

First if-condition failed - the second if-condition applied