Build behaviour (Flow-Driven Development)
Test cases and runs
Write test cases as acceptance tests, run the flow and watch it move through your systems, step back in time, and compare runs and versions.
Open Flows in the appWhat a test case is
A test case is one named situation for a flow, such as "Valid credentials", "Wrong password" or "Missing email". It brings together:
- an input: inline values, or flow input test data;
- the test data: which test data answers at each call, or automatic matching;
- the expected result: one of your expected results, and optionally checks on single steps.
A test case is an acceptance test you can read. When all of a flow's test cases pass, the flow does what you said it should. Each one has a key such as TEST-CASE-AUTH-LOGIN-002.
Write a test case
- Open a flow and press Test in its bar.
- In the Test panel, press Manage…, then New.
- Under Input, pick test data or choose Inline value and type the values.
- Under Test data at each call, leave Automatic or choose test data for a call to force a situation.
- Under Expected response, pick an expected result, or create one with New expected result.
- Optionally add Step checks (a value at a step) and Database & queue expectations (what should be written or sent).
- Press Save test case.
Suggest proposes failure test cases from the flow's input: a missing required field, a wrong type, an empty text. Tick the ones to keep and add their expected results. Duplicate copies a test case to make a variant.
Run it
In the Test panel, choose how other systems answer (Calls answered by):
Neither mode calls real APIs; everything runs on the systems modelled in Rabbinatix.
Pick a test case and press Run, or press Run all. The run moves through the steps and across lanes. Only the branch taken lights up. At the end you see a pass or a fail. On a fail, Why? goes to the failing step and shows each check with its expected and actual value.
Change the input and run again to see how the path changes: steps newly taken glow, and steps no longer taken show as outlines. The flow menu has Edit input and run… and Run all test cases.
Time travel
Every step of a run is recorded, so you can move through it in either direction.
- The player moves one step back or forward (← →), replays the run and changes the speed.
- The timeline under the canvas has one mark per step, coloured by system. Click one to jump there.
- In the Test panel's list of steps, a call that answered with an error (400 or more) shows its status in red, and Error at step … above the list jumps to where the error starts. When a call failed because of a call inside it (Checkout's 422 from Order Service, because Payment Service answered 402), it points at the inner one.
- In the Logic view, Follow the run keeps the current step on screen. With All, the column the run moves into centres on it.
Stepping back to the start and forward again shows exactly the same states every time.
Step data
The Step data panel shows what was there at the current step: the step, which system it ran in, what answered it (logic, test data or generated data), its input and its output. Values show as JSON, Tree, Table, Raw, Schema, or as a Diff against the previous step or any step you choose.
- Click a connection to see the value it carried at that step, such as the request body sent from Auth Service to Users DB.
- Why not the others explains which test data was skipped and why.
- Watch keeps a variable in view while you step.
- Secret values are masked; revealing one is recorded in the activity log.
When a database call had no test data, Create test data from this input starts one with the conditions already filled in.
Run history
Every run is stored with the exact versions of the flow, logic and test data it used. Runs are keyed by the day they were made on, in the time zone of whoever ran them, such as RUN-20260928-001.
- Open Run history from the flow menu. Each run shows its result, test case, mode, who ran it and when.
- Open a run to replay it with the versions it used, even if the logic has changed since.
- Select two runs and press Compare to see what differs between them (result, input, output, contract checks and failed checks), then their paths side by side, with the first difference marked.
- On a failed run, Copy as bug report copies the details as Markdown, and Create bug ticket files a bug.
- On Free, the history shows the last 90 days of runs (each test case's latest run always shows). Older runs are kept, and moving to a paid plan shows them again.
Versions and comparing
Flows, logic, test data and expected results keep every saved revision.
- Versions & history on the flow lists its revisions and named versions. Save version names the current state; Restore goes back to an older one.
- In the logic editor's History tab, compare any revision with your current changes. Added steps are green, removed ones red, changed ones amber and moved connections dashed. The text steps show the same change as text, such as
+ Check Account Status.
See Versions and releases for how versions work across Rabbinatix.
Test cases and requirements
Link test cases to requirements, and the requirement shows ✓ while they pass and ✗ when one fails. See Requirements and coverage.
Related
- Test data and expected resultsTest data stands in for databases, APIs and inputs that don’t exist yet; expected results describe the result you expect.
- FlowsBuild a flow from the logic it starts at, see it cross your systems in lanes, and move it from draft to verified.
- Requirements and coverageWrite requirements, link them to flows and test cases, and see which ones your runs prove. Follow any change to the flows it affects.
- Code generationSee the code for a logic as you build it, take it away as files, and check it returns what the test cases returned.
- Step-by-step examplesEvery click and value to build a login flow, a system map, logic and a whiteboard.
