Foundational Concepts

This guide is your reference dictionary for all core terminology in ReAPI.

The Foundation: API Specification

Everything in ReAPI begins with a clear, machine-readable definition of your API.

• API Specification: A digital blueprint of your API, compatible with the OpenAPI standard. ReAPI includes a no-code visual editor to create, import, and manage these specifications. They act as the single source of truth, providing the foundational metadata that powers more efficient, reliable, and intelligent testing.

Test Organization

These concepts define how you structure, group, and automate your tests at a high level.

• Test Case: The top-level container for a single, executable scenario. It bundles a Test Flow with metadata like tags and version history.
• Runner: An executable test suite. It typically uses one or more SELECTOR nodes to dynamically gather a collection of Test Cases by folder or tag.
• Deployment: The bridge to automation. A Deployment links a Runner to a specific Environment, making it a fully configured and runnable entity.

Test Design

These concepts relate to the hands-on process of building the logic within a single Test Case.

• Test Flow: The heart of a test case, representing the actual logic. It’s a visual sequence of connected Nodes.
• Node: An individual action or building block in a Test Flow. You combine nodes visually to create test logic without code. Common nodes include API, IF, LOOP, and CONTEXT.
• $REF: A special node that allows you to reference and reuse another test case within your flow, promoting modularity.

Data & Logic

These concepts define how data is managed and validated within a Test Flow.

• Context (The Data Bus): The core mechanism for passing data between nodes in your test flow. Think of it as a shared clipboard that connects all your test steps.

  Why it matters: Every real-world test needs to pass data between steps—extracting an ID from one API response to use in the next request, preparing test data before making a call, or storing values for assertions. Context is how you chain your test steps together.

  Common patterns:

  • Extract user ID from login response → Use in next API call
  • Prepare request data in CONTEXT node → Send in API request
  • Store expected values → Validate against API response

  Where you modify context:

  1. CONTEXT Node - Visual setup of variables (recommended for most cases)

  2. API Node Context Operations - Extract data from responses (no-code)

  3. Hooks - Complex transformations when needed (scripting)

  4. Script Node - Complex data preparation (scripting)

  📖 Full Guide: See Context & Variables for complete patterns and examples.

• Expressions: The mechanism for working with dynamic data. ReAPI has two modes:

  • JSONata: The default mode, a powerful query language for transforming and extracting data from JSON, ideal for handling API responses.
  • Template Engine (js:): An advanced mode for generating new data from scratch using libraries like Faker.js and Lodash, activated with the js: prefix.

• Assertions: The rules used to validate application behavior. You can attach assertions to an API node to check its response, using a rich set of built-in operators (like equals, isEmail) or custom-defined logic.

Configuration

These components manage how your tests run in different settings.

• Environment: A named configuration that bundles together servers, authentication, and variables for a specific setting (e.g., QA, Production).
• Server: A configuration that defines the base URL for an API in a specific environment.
• Authentication: A reusable profile for authenticating with an API, supporting schemes like Bearer Token, API Key, and Basic Auth.
• Variable Group: A collection of key-value pairs that can be attached to an environment to provide static, environment-specific data.
• Secrets: A secure store for sensitive credentials like API keys or tokens.

Execution & Automation

These concepts relate to the process and results of running your tests.

• Cloud Execution: When a Deployment is triggered, the test suite runs on scalable cloud infrastructure (Google Cloud Functions).
• Results & Snapshots: After a run, you get a detailed execution log for every step. You can also create a Snapshot—a shareable, private URL for a specific test result—to streamline debugging with your team.
• Notifications: Receive automated notifications (e.g., via email) for cloud runs to stay informed of test outcomes.

Execution Environments

ReAPI provides multiple environments to run your tests, offering flexibility for different stages of your workflow, from initial design to production monitoring.

• Browser Environment: During the design and debugging phase, tests are executed directly in your web browser. This provides instant, real-time feedback. A dedicated Chrome Extension is available to automatically handle CORS issues, ensuring a smooth local development experience.

• Self-Hosted Environment (Node.js CLI): For teams who want to run tests on their own infrastructure (e.g., within a private network or on a specific CI/CD machine), ReAPI provides a powerful Node.js CLI tool. This gives you full control over the execution environment.

• ReAPI Cloud Environment: For fully managed, serverless execution, you can run your tests on the ReAPI Cloud. This is the easiest way to automate your tests, with built-in scheduling (cron or rate-based) and integration via webhooks, all without managing any infrastructure.

Extensibility

For advanced scenarios, ReAPI can be extended with custom code.

• Mocking: ReAPI includes a cloud-based mock server to simulate API responses, allowing you to test frontend applications or services that have dependencies that are not yet available.
• Custom Code: Developers can write custom JavaScript to create:
  • Value Generators: Functions to generate dynamic data.
  • Custom Assertions: Reusable validation logic.
  • Hooks: Code that runs before a request (beforeRequest) or after a response (afterResponse).
  • Scripts: Complex logic within a SCRIPT node.