Core Concepts

Before diving deeper into QANode, it is important to understand the key concepts that form the foundation of the platform.

Hierarchy Overview

Projects
├── Scenarios (Flows)
│   ├── Nodes
│   │   ├── Configuration
│   │   ├── Connections (Edges)
│   │   └── Outputs/Inputs
│   └── Executions (Runs)
│       ├── Steps
│       ├── Logs
│       └── Artifacts and files
├── Components
│   ├── Input Contract
│   ├── Reusable Flow
│   └── Output Contract
└── Suites
    ├── Ordered Scenarios
    ├── Scheduling (Cron)
    └── Suite Executions

Projects

A project is the highest level of organization. It groups test scenarios and suites related to a system, feature, or team.

Each project has:

• Name and description
• Status: Active, Completed, Cancelled, or Archived
• Dates: Planned start and end dates
• Documentation: Attached files (requirements, specifications, etc.)
• Statistics: Number of scenarios, suites, and recent executions

Scenarios (Flows)

A scenario (also called a flow) is a test case represented visually as a graph of connected nodes. Each scenario describes a sequence of actions to be executed — such as navigating a website, calling an API, or querying a database.

Scenarios are composed of:

• Nodes: Individual actions (click, type, make a request, etc.)
• Connections (Edges): Links between nodes that define the execution order
• Configurations: Parameters for each node

Visual Example

[Navigate] → [Fill email] → [Fill senha] → [Click login] → [Assert welcome]

In this example, each box is a node and the arrows represent connections indicating the execution flow.

Nodes

Nodes are the fundamental building blocks of a scenario. Each node performs a specific action and can produce outputs that are consumed by subsequent nodes.

Node Categories

Anatomy of a Node

Each node has:

• Input Handles (●): Points where connections from other nodes arrive
• Output Handles (●): Points from which connections leave to other nodes
• Configuration: Fields specific to the node type
• Outputs: Data produced after execution (accessible via expressions)
• Label: Identifying name of the node in the flow

Outputs and the Expression System

When a node is executed, it produces outputs — data that can be used by subsequent nodes. To access this data, use the expression system with the {{ }} syntax:

{{ steps["Node Name"].outputs.property }}

Examples:

{{ steps["http-request"].outputs.body.token }}    → Token from an API response
{{ steps.login.outputs.extracts.userName }}   → Text extracted from a page
{{ steps.query.outputs.rows[0].email }}       → First email from a SQL result

For full details, see the Expressions documentation.

Reusable Components

A component is a reusable flow with an input and output contract. It lets you encapsulate a sequence that appears in several scenarios, such as login, test-data setup, common validation, or a helper query.

Components have:

• Input: fields the scenario must provide;
• Internal flow: nodes executed inside the component;
• Output: value returned to the scenario;
• Status: draft or published.

After publishing, the component appears in the scenario editor palette and can be dragged to the canvas like a regular node.

For details, see Reusable Components.

Connections (Edges)

Connections link the output of one node to the input of another, defining the execution order. QANode executes nodes in topological order — meaning a node is only executed after all nodes connected to its input have been completed.

Conditional Connections

Some nodes have multiple conditional outputs:

• If → true and false outputs
• Switch → outputs for each case + default
• Loop → loop (next iteration) and done (end of loop) outputs

Only the path corresponding to the evaluated condition will be executed. Nodes in inactive paths will be skipped.

Executions (Runs)

An execution is an instance of a scenario being processed. When running a scenario, QANode:

1. Resolves the topological order of the nodes
2. Executes each node sequentially
3. Evaluates expressions and injects data from previous outputs
4. Records logs, screenshots, files, and artifacts
5. Makes execution results available

Each execution has:

• Status: running, success, or failed
• Duration: Total execution time
• Steps: Individual result of each node
• Artifacts: Screenshots and generated files
• Logs: Detailed messages from each step

Test Suites

A suite groups multiple scenarios for sequential execution. Suites are useful for:

• Running multiple scenarios in order
• Scheduling periodic executions (daily, hourly, etc.)
• Stopping on the first failure (optional)

Scheduling

Suites can be scheduled using cron expressions:

Variables

Variables are global reusable values in any scenario. Supported types:

Access variables in your flows with: {{ variables.variableName }}

Credentials

Credentials store connection information securely and centrally. Supported types:

• HTTP/API — Base URL, authentication, headers
• PostgreSQL, MySQL, MariaDB, SQL Server, Oracle — Database connection data
• MongoDB — URI or connection data
• SSH — Host, user, password, or private key

Credentials can be referenced by nodes that need a connection, preventing passwords from being exposed in flows.

Next Steps

Now that you know the core concepts:

• Flow Editor — Learn to use the visual editor
• Node Reference — Learn about all nodes in detail
• Expressions — Master the interpolation system