// collection runner

Collection Runner

Collection Runner executes a list of saved requests in sequence. It is designed for smoke tests, regression checks, and multi-step flows where one request feeds data into the next — all running locally.

What It Is For

  • Run a sequence of requests without triggering them manually one by one
  • Share a single active environment across the entire run
  • Chain values between steps using test scripts and environment variables
  • Stop on first failure or continue through the full queue
  • Save runner configurations for repeatable workflows

Opening Collection Runner

  1. Open Resonance and navigate to the collection you want to work with
  2. Open the Collection Runner panel from the interface
  3. Select the requests to include and arrange them in execution order

Building a Run

  1. Add the requests that belong to your scenario
  2. Reorder steps to match the expected flow
  3. Pick the environment to run against
  4. Review each request for variables, auth settings, and scripts
  5. Save the configuration if you plan to reuse it

Runner Options

  • Stop on error — halt when a request fails or a script throws
  • Continue on error — complete the full queue regardless of failures
  • Delay between requests — add a wait between steps
  • Saved configurations — reload commonly used flows without rebuilding them

Variable Chaining

Extract values from one response and write them to the environment so later steps can use them in URLs, headers, or bodies.

// Request 1 — test script
const data = JSON.parse(response.body);
environment.set('authToken', data.token);
environment.set('userId',    data.user.id);

// Request 2 — uses those values automatically
// Authorization: Bearer {{authToken}}
// GET {{baseUrl}}/users/{{userId}}
  • Use test scripts to capture IDs, tokens, and any workflow state
  • Keep variable names stable so saved runner configs stay valid across API changes

Typical Workflow

  1. Send a login request and capture the access token
  2. Create a resource and store the returned identifier
  3. Fetch the resource to verify its data
  4. Update or delete it in a final cleanup step

Monitoring a Run

  • Track progress through the queue in real time
  • Inspect response details for any failed step
  • Review script output when a chained variable was not set as expected
  • Use timing data to spot unexpectedly slow endpoints

Best Practices

  • Keep each runner focused on one workflow or test scenario
  • Prefer environment variables over hardcoded IDs or tokens
  • Validate important response fields in scripts — not just status codes
  • Include cleanup requests when your scenario creates data on a shared system
  • Add small delays if the target service needs time to settle between writes

Troubleshooting

Later requests fail because a variable is missing

  • Check the earlier response body and confirm the test script extracted the expected field
  • Verify variable names in scripts match the {{placeholder}} used by later requests
  • Inspect runner output to find where the chain first broke

Execution order is wrong

  • Reorder the request list before starting the run
  • Save the corrected sequence so it is preserved for next time

Run stops too early

  • Check whether Stop on error is enabled
  • Review failed assertions or script exceptions in the step results
  • Switch to Continue on error to get a full picture across all requests

Next Steps