Context Variables Guide

Overview

Context variables play a crucial role in managing dynamic data within ReAPI test executions. They allow users to store, modify, and reuse values across test steps, enabling flexible, efficient, and automated workflows.

What Are Context Variables?

Context variables are temporary key-value pairs available during test execution. They facilitate:

• Storing API responses for later use.
• Sharing data across steps without requiring hardcoded values.
• Creating dynamic assertions by comparing expected and actual results.
• Handling session-based values, such as authentication tokens.

Why Use Context Variables?

Utilizing context variables enhances test efficiency by:

• Reducing redundancy: Eliminates the need for manual data input across multiple steps.
• Supporting dynamic testing: Adapts test data seamlessly to changing requirements.
• Enhancing maintainability: Enables centralized data management without modifying numerous test steps.
• Facilitating complex test flows: Allows for real-time data storage and modification throughout execution.

How Context Variables Work

1. Initialization

• At the start of a test, context variables include all values from the selected environment variable group.

2. Propagation and Scope

• Context variables flow from the start node to each subsequent step.
• Modifications take effect immediately and apply to the next step.
• Parallel execution isolates context variables, ensuring no conflicts arise from uncertain execution order.

3. Modifying Context Variables

Context variables can be updated dynamically using:

• API responses: Extract values from API call responses.
• Expressions (Jsonata): Transform data using powerful expressions.
• Predefined functions: Generate values using Faker.js, ReAPI utilities, or custom scripts.

Accessing Context Variables

Context variables can be accessed in several areas, including API configurations, assertions, context operations, and logic nodes.

Placeholder-Based Access vs. Explicit Access

When accessing context variables, there are two main scenarios:

1. Within API Configurations

   • When using context variables in API configurations such as path parameters, query parameters, or request bodies, you must use placeholders. However, you do not need to prepend context. when using placeholders.
   • Example: Setting a query parameter:

     userId={{userId}}
     Here, userId is automatically parsed from the context.

2. Within Logic Nodes and Assertions

   • In logic nodes like If conditions or assertions, you must explicitly reference context variables using the context. prefix.
   • Example: In an If Node condition:

     context.enabled = true
     If context. is omitted, enabled will not be recognized as a context variable.

Visualizing Context Variables in ReAPI

ReAPI’s no-code editor provides an intuitive way to track and manage context variables:

• Step-Level Tracking: Displays modified keys at each step for easy reference.
• Before/After State Visualization: The UI captures and displays the context variables before and after each step, allowing users to understand changes in real-time.
• Context Modifier for Debugging: Each step features a built-in modifier that allows manual changes to context variables. Users can adjust values and execute a specific step without running the entire flow, streamlining debugging.

Example Usage

Example: Using Context Variables for Dynamic API Testing

1. Generate a random title using Faker.js:

   {
     "key": "title",
     "value": "faker.lorem.sentence()"
   }
2. Use {{context.title}} in the request body of an API call.
3. In an assertion step, verify that context.title matches the response data.

Key Benefits

• Avoids hardcoded values, making tests more adaptable.
• Ensures data consistency across multiple steps.
• Facilitates dynamic test scenarios with auto-generated values.

Best Practices

• Use meaningful variable names to enhance clarity and organization.
• Minimize unnecessary modifications to optimize performance.
• Understand scope behavior to prevent unexpected outcomes, especially in parallel execution scenarios.
• Validate values before assertions to ensure expected results.

Conclusion

Context variables are a fundamental component of ReAPI’s testing framework. They enable flexible, scalable, and automated test execution by dynamically managing data throughout workflows. With ReAPI’s built-in visualization and debugging tools, tracking and modifying context variables becomes seamless. Mastering their use will greatly enhance your ability to create powerful, automated test cases.