A real inbox for every run
Each run gets an address under inbox.rig.ironfang.com 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.
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.
No card required. One suite file beside your code, one run per test, and addresses that stop the moment the run ends.
Allocated for this run
run-k7c3...@inbox.rig.ironfang.com
hooks.rig.ironfang.com/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.
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 rig 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.yamland runironfang 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 rigsyncs, 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@v1exports every address to the job;finish@v1prints the verdicts and fails the step when the run fails.MCP tools
19 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
Free each month, then pay as you go
Every account has these free allowances each month. With Pay as you go switched on, usage past them is charged at the rates below, within the monthly limit you set. Prices exclude VAT.
Interactions
Each inbound email, callback or mock exchange recorded as an event.
5,000 interactions free each month
| Paid units after the free allowance | Rate per 1,000 |
|---|---|
| First 100,000 | £0.50 |
| Next 900,000 | £0.35 |
| Above 1,000,000 | £0.25 |
One interaction is one accepted inbound email, inbound callback or mock exchange, request and response together. Creating projects, suites, runs and resources, faults, replays, waits and reads are never counted, and a sender's retry that carries the same Message-ID or Idempotency-Key counts once.
When the free allowance is used up without Pay as you go, or a usage limit is reached, an interaction is refused rather than charged: the sender gets the billing code, and the run's timeline records what arrived and why.
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.
Operational limits
The same on every account. Paying more never lifts them.
- Up to 50 active runs per account
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 rig 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.
No card required. Ironfang Rig records what reached the addresses it allocated; it does not run your tests or inspect your application.