From a session to a regression

Capture real traffic once. Replay it anywhere. Turn the responses into assertions that ship with the request.

Same recording format every protocol Bowire knows produces. Same replay engine the mock server and the security scanner use. bowire scan with a recording = vulnerability template; bowire mock with a recording = live fixture; bowire call --recording in CI = regression test.

Capture — one click, every protocol

Click Record, run the sequence, click Stop. Every request, response, status, header, and inter-call timing ends up in one JSON file — gRPC streams next to SignalR hub invocations next to MQTT publishes next to REST hits.

The recording format (.bwr) is plain JSON. Version it in Git, review it in a PR, diff it across releases. Bowire writes one file per session by default; bowire call --recording <file> + the Replay button + bowire mock all read the same shape.

Cross-protocol on purpose: one capture against a service that uses gRPC for internal calls + SignalR for live updates + REST for client APIs ends up as one timeline you can replay end-to-end, not three separate test fixtures glued together by a script.

Recording feature reference →

Replay — spot drift across environments

Switch the environment dropdown, hit Replay, get a side-by-side diff against the original capture. Same calls, different host, same expectations.

Variables in the recording substitute against whatever environment you replay against (${env.baseUrl}, ${env.token}, …). The diff highlights status changes, response-shape drift, missing fields, latency spikes — you see immediately whether Staging still behaves like Prod or where the rollout broke something.

For long-running comparisons (week-over-week regression suites): drop the recording in CI behind bowire call --recording, point at --env staging, fail the build on any diff that crosses a configured threshold.

Environments feature reference →

flowchart LR
    subgraph cap["1 · Capture"]
        direction TB
        Live(["Live session"])
        BWR[("session.bwr")]
        Live --> BWR
    end
    subgraph rep["2 · Replay"]
        direction TB
        Dev(["Dev"])
        Stag(["Staging"])
        Prod(["Prod"])
    end
    subgraph ass["3 · Assert"]
        direction TB
        Ops(["eq · gt · contains · matches"])
    end
    BWR --> Dev
    BWR --> Stag
    BWR --> Prod
    Dev --> Ops
    Stag --> Ops
    Prod --> Ops
    Ops -->|"all match"| Pass(["pass"])
    Ops -->|"any miss"| Fail(["fail CI"])

One .bwr file drives three replays across environments; the same Newman-style assertion set runs against each. bowire call --recording wires the same loop into CI — fail exit code on any miss.

Assert — next to the request, not in a separate file

Eleven Newman-style operators (eq, ne, gt, contains, matches, type, …) target any value via response.path.to.value JSONPath. Stored per method, replay with every invocation, green/red badge inline.

Streaming responses get assertions on the accumulated frames — “expect at least 3 frames of type TICK within 2 s” is one rule. No plugins, no pipeline, just a test that lives next to the request and ships in the same recording file.

Export the recording (including its assertions) into your repo, run it from CI, fail the build when an assertion flips. The same file drives the interactive workbench replay and the headless CI run — no second test fixture to maintain.

Test-assertions feature reference →

Try the regression flow

The shortest end-to-end story: capture a session against staging, replay it against prod, lock the responses with assertions, drop the file in your CI.

Tester workflow walkthrough Quickstart Feature reference

A different lane fits better? All solution lanes →