RabbinatixDocs
Sign inGet started

Build behaviour (Flow-Driven Development)

Flows

Build a flow from the logic it starts at, see it cross your systems in lanes, and move it from draft to verified.

Open Flows in the app

What a flow is

A flow is one complete business process, such as Login or Checkout. It starts at one place, a logic in one system, and follows that logic as it calls other systems. A login flow might go Web App → Auth Service → Users DB → Auth Service → Web App.

You don't draw the lanes. Rabbinatix follows the Call Contract steps and database, queue and external calls in the logic and works out which systems the flow crosses. The lanes are views of the real logic, so changing the logic changes the flow.

Each flow has a key such as FLOW-AUTH-LOGIN-001, a status, a criticality and, once you write some, test cases.

Create a flow

  1. Open Flows under Behaviour in the sidebar and press New flow.
  2. Under Where does the flow start?, pick the system.
  3. Under What starts it?, pick Existing logic and choose the logic (an API's endpoint logic or a user action), or pick New, empty starting point to create one.
  4. Give it a name, a description, a Criticality (Critical, Important or Normal) and, if you like, an Owner team.
  5. Press Create flow.

The flow's input is the starting logic's input. You can mark inputs, such as a password, as secret; they are masked in runs.

TipBrowse ready-made flows opens the Store, where you can copy in a tested login or registration flow and fit it to your systems.

The four views

Switch views in the flow's header.

ViewShowsFor
BusinessOnly the key steps, from start to endProject owners and stakeholders
SystemsOne lane per system, the steps in each lane, and the API calls between lanes with their contract status. A function runs in the lane of the system that calls it, even a library function another system ownsEveryone; it is the default
LogicThe logic of one system, with the flow's path highlightedBuilding and debugging
TechnicalAfter a run: the requests, data sent, headers, queries and timings of each callDevelopers

In the Logic view, the chips at the top left pick the system's logic to show. All shows the logic of every system the flow crosses side by side. As One canvas, each system gets a labelled frame and dashed arrows show the calls between systems; during a run the current step follows those calls, and the frame of the system it is in turns amber. As Columns, each system gets its own column that pans and zooms on its own, and the column with the current step is outlined.

Canvas and Flowchart at the top switch how one system's logic, or each column, is drawn. The flowchart shows the steps top to bottom with decisions as diamonds and leaves the values out, as in the logic editor's Flowchart view. During a run the steps that ran carry their step numbers, the current step glows, and the arrows taken are lit, with how many times when it was more than once. Click a step that ran to see it in the inspector. All as One canvas is always drawn as a canvas.

To show a step in the Business view, open its logic and mark it with Key step on the step's right-click menu.

In the Systems view, a lane opens its system and a call between two lanes opens their connection. Right-click a step for What does this step do?, Show in Logic view and Open in Logic editor.

The systems a flow crosses

A flow can cross any system on your map: frontends and mobile apps, backend services, databases, queues and external services. Calls between systems go through the APIs declared on the map. That has two effects:

  • If a contract on the path is broken, the call shows it, and the flow can't pass until it is fixed. See Contract statuses.
  • An API that doesn't exist yet can still be part of the flow. Its answer comes from the provider's logic if it has some, from test data, or from an example generated from the contract.

Databases, queues and external services answer through their operations, such as users.findByEmail. Add operations on the system's Resources tab, or right-click the system on the map and choose New operation. Their answers in a run come from test data.

Show on the system map highlights the flow's path over the map and dims everything else. See System map.

Calling APIs from logic

Inside a logic, a call to another system is a Call Contract step. Its inputs come from the request you declared, and it has one exit for each response status, so the logic has to say what happens on a 200, a 404 or anything else. When the other system's logic fails with an error whose code is an HTTP status (for example Throw Error with code 402, or FAIL 402 in text steps), the call answers with that status and the message, like a real server, and the caller's own step for it runs; an error with any other code stops the run. A system's consumer expectations show up as Call Contract steps in its logic's node list. See Logic.

Flow status

A flow moves through five statuses. Change it by clicking the status in the header.

StatusMeans
DraftBeing designed
ApprovedThe team agreed this is the intended behaviour
In developmentDevelopers are building it
ImplementedThe real code is in place
VerifiedThe real system was checked against the test cases

Moving a flow to Approved or Verified needs the approve permission, which project owners have. Every change is in the activity log.

Critical flows

Mark a flow Critical when a failure should stop a release. Critical flows are pinned on the dashboard, and the safety check blocks a deployment that goes through a critical flow whose latest test case run failed. See Requirements and coverage.

On the flow page

  • The bar: click the name for the flow's settings; Business, Systems, Logic and Technical switch the view; Test opens the Test panel, where you pick a test case and choose how calls are answered (Test data or Real logic). See Test cases and runs.
  • After a run, a thin bar under it holds the player and the result.
  • The side panel: Step data, Tickets, Text steps and What’s linked. The test cases are listed once, in the Test panel under the canvas; its Manage… opens them in the side panel to add, edit, duplicate and delete.
  • The … menu: Check the generated code, Flow settings…, Run history, Requirements & coverage, Real traffic, Walk through, Present, Focus mode, Copy link (to give a teammate), Publish and the tour.
  • Present shows the canvas and the player full screen, fitted to it, for walking people through it. It replays the last run; Test comes back when you leave. In another environment than Development, Development's runs aren't shown.
  • Publish shares the flow in the store. See Reusable logic.

For every click of a full example, see the login example.

With another environment picked in the header, Flows lists the flows of the releases running there, each at the revision deployed there, read-only. See Logic and flows in an environment.

Sticky notes

A sticky note is a short note on the canvas, for you or for everyone. Anyone in the organization or project can add one, viewers included. A sticky note is never part of what it sits on: it has no versions, it isn't reviewed, and Draft mode and draft-first publishing don't hold it back.

  • Add one. Press the sticky note button with the zoom buttons and choose Add sticky note, or right-click an empty part of the canvas and choose Add sticky note here. Type, then press Save (or Ctrl+Enter). An empty note goes away.
  • Who sees it. A new note is Only me: nobody else ever sees it. Choose Organization before saving, or later from the note's menu, and everyone who can open the flow sees it with your name on it.
  • Fold it. The fold button turns a note into a small icon; click the icon to open it again. Folding is yours alone: a shared note you fold stays open for everyone else, and stays folded on your other devices.
  • Change it. Only the person who wrote a note changes it. Double-click the text (or choose Edit) to edit it, drag it by its top bar to move it, or nudge it with the arrow keys. Its menu also has the colours.
  • Delete it. Delete your own from its menu, and Undo brings it back for a few seconds. Someone who may edit the flow can also delete a shared note left by someone else, after a confirm.
  • Hide them. Hide sticky notes in the same button hides every note on flows for you, until you choose Show sticky notes.

Sticky notes sit on the flow's main view, not on the logic or technical view or a run's playback. A note keeps its place on the canvas, so when the flow's steps change it may end up beside another step. Deleting a flow takes its notes to the trash with it, and restoring the flow brings them back.