Lifecycle and Isolation

A hosted mock service is a stub server a vendor runs for you. Its canned replies live in an account on their platform, reachable at an address they control. What you give up is custody: review, rollback and availability.

The POST /imposters response is the created imposter, and its port field holds the number mountebank bound. Read it from that response, or list running imposters with GET /imposters, then build the worker's base URL from it.

Call resetRequests() on WireMock's WireMockServer, or resetAllRequests() from its static client DSL; over the admin API it is DELETE /__admin/requests. It resets the request journal alone, so stub mappings, scenario state and global settings all survive untouched.

Call DELETE /__admin/mappings/{id} with the id WireMock returned when the stub was registered. That removes exactly that mapping and leaves the rest in place, while DELETE on the collection path clears every registered mapping at once.

A fixed port makes the fixture depend on a machine-wide resource nobody owns, so any other process already holding it fails the suite. dynamicPort() has WireMock take a free port at start-up, and the test reads the resolved address back.

WireMockRule is WireMock's JUnit 4 integration, published in wiremock-junit4. On JUnit 5 you take wiremock-junit5 and use either the declarative @WireMockTest annotation, which injects a WireMockRuntimeInfo, or WireMockExtension when you need to configure the instance yourself.

A provider's sandbox proves your request is acceptable to code you did not write: their validation, refusal rules and state transitions run for real. A stub only proves your client handles the answers you already imagined. Neither is production.

Bind-mount the directory holding mappings and __files onto /home/wiremock, the root the wiremock/wiremock image uses, and publish the server's port. Launcher flags added after the image name reach WireMock itself. No image of your own is needed.

WireMock's journal is bounded once --max-request-journal-entries is set, and passing the bound silently evicts the oldest entries. Nothing errors and nothing warns. A count taken afterwards under-reports what a long-lived shared instance received, so the answer is wrong, not missing.

WireMock's standalone launcher reads mappings and __files beneath one root directory. The wiremock/wiremock image sets that root to /home/wiremock. A bind mount landing anywhere else leaves the mapping set empty, so every scaffolding-inspection request goes unmatched and comes back 404.

A shared WireMock has outgrown its pipeline once its singular surfaces collide. It keeps one journal whose cap other teams exhaust, one admin API any job can rewrite, and one health signal that hides both. Measure those before deciding.

Declare the aggregate WireMock artifact, org.wiremock:wiremock, which pulls in the whole embedded library. WireMock 4 also publishes separate modules such as wiremock-core and wiremock-junit5 as an alternative for narrower dependencies. The old wiremock-jre8 artifact no longer exists.

Sandbox outcomes are triggered by inputs the provider designates, not by data that merely looks realistic. Ordinary values fall through to the success path. A refusal or a review hold stays unreachable until you send the published trigger.

Run java -jar wiremock-standalone.jar with --port for the listening port and --root-dir for the directory holding mappings and __files. Without --root-dir the server roots itself in the current working directory. --verbose prints what the server is doing to stdout.

WireMock's POST /__admin/mappings registers one stub mapping per call and hands it back with its id. WireMock's POST /__admin/mappings/import takes a document holding many mappings and loads the whole batch in a single call, adding to what is already registered.

A hermetic suite depends only on what it brings with it. Calling a vendor-hosted mock adds the network, the vendor's availability and an account other people can edit. Any of those can turn a build red without your code changing.

Nothing on the machine promises that block is yours. A second suite, a leftover process or another service can already hold one, and the worst outcome is not a bind failure but a worker quietly reaching another run's imposter.

Nothing releases it automatically. One mb process holds every imposter's listening socket for as long as the imposter exists, so a worker that dies without deleting its imposter leaves the port bound on that machine until mb itself exits.

WireMock's resetScenarios() returns every scenario to its initial state and touches nothing else. resetRequests() empties the request journal and touches nothing else. Neither call removes a stub mapping, and the two stores are fully independent of each other.

WireMock's GET /__admin/health answers 200 only once the admin API is serving, so a pipeline polls it rather than the TCP port. It proves the process is up. It does not prove your bakery pre-order mappings are loaded.

WireMock stores what you send to PUT /__admin/mappings/{id} as the whole mapping under that id. It is a replacement, not a patch, so any matcher missing from your body is gone. Read the mapping first, then put it back complete.

WireMock 4 made its core data classes immutable and gave them builders, so the in-place setters on StubMapping are gone. Instead derive a new mapping: WireMock 4's StubMapping.transform takes a lambda that sets the request on a builder.

Definitions held in a vendor account change outside your version control. Treat that hosted mock as an environment, not a repository. Restrict who may edit it, keep an exported copy under review, and record who changed what and when.

Shared sandbox state breaks isolation. Parallel runs see each other's records, share a throttle you cannot raise, and get no teardown at all. The provider owns the data and the outages, so partition per run and stub the rest.

Stop computing the port yourself. Post the imposter to mountebank with no port field, and mountebank binds a free one and returns it in the created imposter. A pre-computed number is only free until someone else binds it.

WireMock's resetAll() delegates to resetToDefaultMappings(), which empties the live stub set and the request journal, then reloads only the mappings the server read at start-up. A stub added later with stubFor() was never a default, so it is gone.

WireMock's --admin-api-basic-auth makes the whole /__admin surface demand credentials. Nothing on the network can then silently rewrite a shared instance's stubs. It partitions nothing, though: every job holding that one credential still shares a single mapping set.

Make the start-up mapping set the contract and forbid suite-wide stubFor() baselines, then let suites use only the narrow calls, resetRequests() and resetScenarios(). Reserve WireMock's resetAll() for the moment a suite genuinely wants the start-up set back.

In Mountebank, POST /imposters/:port/stubs adds one stub to an imposter that is already listening, and PUT on that path replaces its whole stub list. WireMock has no imposter object: it registers mappings with POST /__admin/mappings.