TestingOps.ai

Process models (BPMN) · Native connection · Exported file link

Camunda and TestingOps: test scenario candidates from your BPMN processes

A Camunda process already names the decisions, timers and error events a test has to cover. TestingOps reads the BPMN from Web Modeler or the Camunda 7 engine and lists the paths through it as scenario candidates for your testers and agents.

  • Native connection
  • Exported file link
  • Available
Request a demo Camunda docs: manage API clients
Connection
Native connection, Exported file link
Writes back
Nothing, it only reads
Last checked
7 Nov 2026

In short

Camunda and TestingOps in short

The Camunda connection reads BPMN models from Camunda 8 Web Modeler through an API client, or the latest deployed version of a process definition from the Camunda 7 engine REST API; a link to a .bpmn file, for example from Desktop Modeler in Git, works in both modes.

Each process becomes a knowledge-base document with its steps, gateway outcomes, boundary events, inline form fields and numbered paths from start to end, bounded to 30 paths per process and 60 steps per path.

The paths are scenario candidates for review: agents and testers write the scenarios and cases from them, and TestingOps does not deploy, start or change your processes.

What it does

What it does for your testing

  1. 1

    Gateway conditions become test conditions

    Input
    Exclusive and inclusive gateways with a conditionExpression or a named sequence flow
    TestingOps
    Shows each outgoing flow's name or condition in brackets on the path it starts
    Output
    A scenario candidate per outcome, with the condition the test data has to meet
  2. 2

    Timers and errors become exception paths

    Input
    Boundary events, such as a timer on a user task or an error on a service task
    TestingOps
    Branches a path from the activity, for example On timer, and lists the event under Exceptions
    Output
    Candidates for timeout and failure scenarios that happy-path tests miss
  3. 3

    Form fields become test data hints

    Input
    Inline form fields in the BPMN, such as Camunda 7 camunda:formField with label, type and constraints
    TestingOps
    Lists them per task
    Output
    Values and validation constraints agents use when they write the steps

Step by step

How it works

  1. Connect Camunda 8 or Camunda 7Under Integrations → Platforms → Process models (BPMN 2.0) → Camunda, leave the address empty for SaaS, or enter a Self-Managed Web Modeler URL or a Camunda 7 …/engine-rest address, with a client ID and secret (Camunda 8) or a user name and password (Camunda 7).
  2. Link a processTest connection lists Web Modeler BPMN files or deployed process definitions. In the project's Knowledge tab, add a source under Process models (BPMN 2.0): pick one, or paste a Web Modeler link, a Camunda 7 process key or a .bpmn file link.
  3. Sync reads the BPMNSync now downloads and parses the model; automatic syncs follow (hourly by default) and skip a model whose revision or definition did not change.
  4. Paths become candidatesEach process becomes one document with steps, decisions, exceptions, form fields and its paths from start to end.
  5. Review and write scenariosAgents and AI case generation read the document from the knowledge base; scenarios and cases are written from the candidates you keep and reviewed like any other test design.

DMN and form files in Web Modeler are refused; only BPMN files are read.

Connect

Setup

  1. Camunda 8 SaaS: create an API client and copy its client ID and secret. Self-Managed: note the Web Modeler address and, if needed, the Keycloak token URL. Camunda 7: note the …/engine-rest address and a user that can read process definitions.
  2. In TestingOps, open Integrations → Platforms → Process models (BPMN 2.0) → Camunda, enter the address (empty for SaaS), the client ID or user name and the client secret or password, then select Test connection and Save.
  3. In the project's Knowledge tab, select Add source under Process models (BPMN 2.0) and pick a model, or paste a Web Modeler link, a Camunda 7 process key or a .bpmn file link.
  4. Select Sync now. Automatic syncs then pick up new revisions and deployments.

Documentation: Camunda docs: manage API clients · Camunda Web Modeler API

Where you connect it in TestingOps: Integrations → Platforms → Process models (BPMN 2.0) → Camunda

Use cases

Use cases

Cover the decisions of an approval process

Trigger
A team links its approval process from Web Modeler
Uses
Exclusive gateways with their conditions and the paths they open
Agent activity
Writes one scenario per gateway outcome, with data that meets each condition
Result
Draft scenarios that name the gateway and condition they test
Condition
Each combination of outcomes is a separate path, and only the first 30 paths are listed

Test timeouts and failures, not only the happy path

Trigger
A process with timer and error boundary events
Uses
The exceptions listed per activity and the paths that branch from them
Agent activity
Writes scenarios for a user task that times out and a service task that fails
Result
Exception scenarios next to the main flow
Condition
Timer durations and expressions are not parsed, only the event type

Test the version that is deployed

Trigger
A Camunda 7 process key is linked
Uses
The latest deployed version of the process definition, tenant aware
Agent activity
Works from the version that actually runs, not from a draft
Result
Candidates that follow each new deployment, because a deployment changes the definition ID
Condition
Older deployed versions are not read

Capabilities

Capabilities and limits

What is read

  • Camunda 8: BPMN files in Web Modeler, through Hub API v2 or, on Camunda 8.8 and 8.9, Web Modeler API v1; up to 1,000 listed
  • Camunda 7: the latest deployed version of process definitions and their BPMN 2.0 XML from the engine REST API; up to 500 listed, tenant aware
  • A .bpmn file link, for example a Desktop Modeler file in Git, in either mode
  • Per process (named after its pool when there is one): start, end, intermediate and boundary events with their type, such as timer, error or message; tasks, including user, service, script, business rule, manual, send and receive tasks; call activities, without following the called process; sub-processes, ad-hoc sub-processes and transactions with their inner steps; exclusive, inclusive, parallel, event-based and complex gateways; sequence flows with their name or condition; lanes; documentation; inline form fields such as camunda:formField
  • Not parsed: message flows between pools, data objects and data stores, text annotations, the DMN tables behind business rule tasks, linked forms, and timer or expression details beyond the event type

What is produced

One knowledge-base document per process: steps with kind, lane and documentation, decisions with their outcomes, exceptions from boundary events, form fields, and numbered paths from start to end marked as test scenario candidates

Where it can write

Nothing in Camunda: models are only listed and downloaded

How it connects

  • Camunda 8 SaaS: an API client (client ID and secret); tokens come from Camunda's login service
  • Camunda 8 Self-Managed: the Web Modeler address and, if needed, a Keycloak token URL
  • Camunda 7: the engine REST address with anonymous access, Basic (user name and password) or a bearer token in the password field

Account and permissions

  • Camunda 8: an API client that can read your Web Modeler files
  • Camunda 7: a user that can read process definitions, or anonymous access where your engine allows it
  • File links on a Camunda connection are fetched without a token; private files need the BPMN 2.0 file connection

Limits

  • Paths are bounded: at most 30 per process and 60 steps per path; a loop is followed once and the path ends with "back to" the step it returns to; each outgoing branch of a gateway, parallel and inclusive ones included, becomes its own path, so branches are not combined
  • Paths are candidates for review: no TestingOps scenarios or cases are created from them automatically
  • Linked Camunda forms and DMN tables are not parsed; only inline form fields are
  • When Camunda's rate limit is reached, the sync stops with an explanation and the next sync tries again
  • Up to 12,000 characters per process section and 200 processes per model; files and exports up to 15 MB

Example

Example: how a team uses it

Illustrative scenario, not a customer story.

A team links its loan approval process from Web Modeler. The document lists an exclusive gateway, "Credit score sufficient?", with the conditions =score >= 600 and =score < 600, and a timer boundary event on the Review application user task.

The paths show three candidates: approval, rejection and the escalation when the review times out. An agent writes a scenario for each, with test data on both sides of the score condition, and the team reviews them before cases are written.

Frequently asked questions

Does it work with Camunda 8 and Camunda 7?

Yes. The address decides: empty or a Web Modeler URL for Camunda 8, an …/engine-rest address for Camunda 7. A Camunda 7 process key on a Camunda 8 connection is refused with guidance.

Which Camunda 8 API does TestingOps use?

It asks Web Modeler once which API it offers, then uses Hub API v2 (Camunda 8.10 and later) where it exists, or Web Modeler API v1 on Camunda 8.8 and 8.9.

How many paths are listed per process?

Up to 30. Paths are walked from each start event, with up to 60 steps per path; a loop is followed once, and each branch of a parallel gateway is listed as its own path rather than combined. Treat the list as candidates to review.

Are Camunda forms and DMN decisions read?

Inline form fields defined in the BPMN, such as camunda:formField, are listed with label, type and constraints. Linked forms and the DMN tables behind business rule tasks are not parsed, and DMN or form files in Web Modeler are refused.

Does TestingOps run or deploy our processes?

No. It downloads and reads the BPMN. It does not deploy, start or change processes, and it does not run process tests on the Camunda engine.

Can we link a .bpmn file from Git instead?

Yes, in either mode. Through the Camunda connection the file is fetched without a token, so for a private file use the BPMN 2.0 file connection with an access token.

Next step

See your own process as scenario candidates: request a demo and bring a BPMN model from Web Modeler or a Camunda 7 engine.

Request a demoMore process models integrations