Ironfang Rig

Integration test environments

Real email. Real callbacks.
Your test run.

Give the application under test a disposable outside world: a fresh inbox, a public callback URL, a mock endpoint and a route to your machine, allocated for one run, with a record of everything that reached them.

Create a free account Read the docs GitHub Action

No card required. One suite file beside your code, one run per test, and addresses that stop the moment the run ends.

Ironfang Rig / run timelineExample output

Allocated for this run

run-k7c3...@inbox.rig.ironfang.uk

hooks.rig.ironfang.uk/h/...

21 events

in sequence, nothing missing

#5email.receivedVerify your account
#6callback.receivedPOST / from Stripe
#8connector.request.completedlocalhost:8080 -> 200
#16fault.injectedduplicate, copies 1
#21connector.request.completedlocalhost:8080 -> 200

Forwarded to your machine through an outbound connector. No inbound port.

run 01a0b9 / 20m TTL 5 of 5 expectations passed

Everything a run receives

Addresses that exist for one run

A suite names the identities an application needs from the outside world. Each run gets fresh ones, unguessable and unique to it, and they stop the moment the run ends.

A real inbox for every run

Each run gets an address under inbox.rig.ironfang.uk that accepts mail from anywhere. The message is parsed, its subject, links and one-time codes lifted for matching, and the raw bytes kept as evidence.

Public callback URLs

Register an unguessable URL with the payment provider, the carrier or your own queue. Every request is recorded with its method, path, body and a hash, and the sender gets a 200 at once.

Forwarded to your machine

Bind a callback to a route label and run ironfang-connect beside the application. Requests reach a local port over an outbound socket, and the local response is recorded. No inbound port, no tunnel to configure.

Mock HTTP endpoints

Ordered rules match method, path, headers and JSON fields, and answer with a status, body and delay you chose. The same request gets the same answer every time.

Faults on purpose, and replay

Delay, duplicate or drop a forwarded callback, or make a mock answer a chosen status. Replay a recorded callback to prove idempotence. Every firing is an event beside the one it acted on.

A timeline you can keep

Every observation is an event with a contiguous sequence number. Wait on the next one, judge expectations at the end, and export the whole run as a ZIP with a manifest of hashes.

Suites persist. Runs are disposable. Resources have explicit lifetimes.

Every resource, event and bound is in the documentation.

Suite as code

One file beside the code. One run per test.

The suite file names the identities the application needs and what a run must observe. The CLI syncs it, starts a run, hands the addresses to your test process as environment variables, and finishes the run with a verdict when the process exits.

Commit ironfang.rig.yaml and run ironfang-rig run -- npm test.
Your tests read the inbox, callback and mock addresses from the environment.
Wait for the events you care about; replay or interfere on purpose.
The expectations are judged against the timeline and the exit code says pass or fail.

version: 1
project: acme-shop
suite: checkout
resources:
  customer_email:
    type: email
  stripe_callback:
    type: callback
    connector:
      route: stripe
expectations:
  - id: order_email
    resource: customer_email
    event: email.received
    match: { subject_contains: "Your order" }
  - id: stripe_forwarded
    resource: stripe_callback
    event: connector.request.completed
    match: { outcome: delivered, status: 200 }

Three ways in

From the terminal, from CI, or from an assistant

The same runs, timeline and verdicts whichever way the run is started.

Command line
ironfang-rig syncs, runs, waits, replays and exports evidence. A single static binary for Linux, macOS and Windows, with a checksums file per release.
GitHub Actions
ironfang-ltd/rig-action/start@v1 exports every address to the job; finish@v1 prints the verdicts and fails the step when the run fails.
MCP tools
Eighteen tools on the Ironfang MCP server, so a coding agent can start a run, prepare the local connector, wait on the timeline and arm a fault without leaving the editor.

Pricing

Included with your Ironfang account

Ironfang Rig is in its initial release. There is no separate plan and no charge for runs, resources or events, within the documented limits.

What you need

A platform API key with Rig scopes, minted in the portal. The same account as the other products.

What is bounded

Runs live up to 24 hours; 32 resources and 64 expectations per suite; 500 messages, 1,000 callbacks and 5,000 mock calls per run.

What comes next

Usage-based pricing will be published on this page before anything is charged. Nothing you build against the API changes when it is.

Questions

What Ironfang Rig does and what it does not

Does Ironfang Rig run my tests?: No. It is the outside world your tests talk to: the addresses, the record of what reached them and the interference you asked for. Your test runner, your assertions and your application stay yours, wherever they run.
How does a callback reach an application on my laptop?: Through ironfang-connect, a small binary that dials the gateway over an outbound WebSocket with a single-use token minted for the run. The platform only ever names a route label; what the label points at is decided on your command line and never leaves your machine.
Is anything random?: No. Faults fire on the next observation they apply to, the same number of times you asked for. Waiting for an event reads the timeline first, so the same timeline and the same request always answer the same event. Two runs of the same suite against the same traffic give the same verdicts.
What happens to the data afterwards?: Addresses stop accepting the moment a run ends. Raw message and request bytes are kept for seven days and the run with its timeline for ninety, then deleted. Export the evidence bundle before then if a run must outlive it.

Less to operate. More to ship.

Give your tests the outside world.

Commit a suite file, start a run, and watch real email and real callbacks arrive on a timeline you can keep.

Create a free account Read the docs

No card required. Ironfang Rig records what reached the addresses it allocated; it does not run your tests or inspect your application.

Real email. Real callbacks.Your test run.