A collaborator exposes a suspend function that returns Unit. How do you stub it in MockK without inventing a return value, and what exactly does MockK's coJustRun do?

## Why a Unit-returning suspend function still needs a stub A MockK mock created with `mockk<T>()` is *strict*: it has no behaviour at all until you record one. When production code calls a member the mock has no answer for, MockK throws a `MockKException` whose message begins with `no answer found for:` followed by the mock name and the call. The return type is irrelevant — a function declared `suspend fun record(event: String)` returns `Unit`, but MockK will not silently invent `Unit` for you on a strict mock. `Unit` is a value like any other, and the strictness is deliberate: it forces every interaction the test relies on to be visible in the test. ## coJustRun: the suspend form of the do-nothing stub MockK ships a pair of shorthands for that case. `justRun { obj.method() }` is the non-suspend one; `coJustRun { obj.suspendMethod() }` is the suspend-capable one — its block is a suspending lambda, so a suspend call may legally appear inside it. Semantically `coJustRun { audit.record(any()) }` is exactly `coEvery { audit.record(any()) } just Runs`, which itself is `coEvery { … } returns Unit`. Three spellings, one behaviour: MockK records a stub for the matched call, the call does nothing when invoked, and the invocation is added to the mock's recorded-call list so verification can see it. The reason a separate `co*` function exists at all is Kotlin's type system, not MockK's internals. The DSL block of `justRun`/`every`/`verify` is an ordinary lambda; you cannot call a suspend function inside one, so the code would not compile (`Suspension functions can be called only within coroutine body`). The `co*` variants declare their block as `suspend`, so the recording call compiles. ## Creation-time alternative: relaxUnitFun If a collaborator has many fire-and-forget members — loggers, audit sinks, metric recorders, event publishers — stubbing each one is noise. Create the mock with `mockk<Audit>(relaxUnitFun = true)` or annotate it `@MockK(relaxUnitFun = true)`, and MockK pre-answers every member whose return type is `Unit`, including suspend members, while leaving value-returning members strict. `MockKAnnotations.init(this, relaxUnitFun = true)` applies the same flag to all annotated mocks in the class at once. The tradeoff is the usual one: per-call `coJustRun` keeps the test's assumptions explicit and still fails loudly if the code calls a *different* Unit member you did not expect; `relaxUnitFun` is quieter and shorter. ## Stubbing is not verification A very common confusion is treating `coJustRun` as an assertion. It is not — it only supplies behaviour. If the test's point is "the audit entry is written", you still need `coVerify { audit.record("checkout") }`. And it must be `coVerify`, not `verify`: the verification block for a suspend call has to be a suspending lambda for the same compile-time reason as above. ## When coJustRun is the wrong tool - **You need more than one answer.** `coJustRun` states a single do-nothing behaviour. When the first call must succeed and a later one must fail, write the stub out with `coEvery` and chain answers explicitly. - **You need the argument.** If the test wants to inspect what was passed, either capture it, or use `coAnswers { … }` so the answer body can read the arguments. - **The function returns a value.** `coJustRun` only makes sense for `Unit`; anything else needs a real answer. ## Mental model `coJustRun` sits at the intersection of two axes MockK keeps orthogonal: *suspend vs blocking* (which decides whether you use the `co` prefix) and *what answer to give* (which decides the terminator). `coJustRun` is simply the point "suspend" × "do nothing, return Unit", packaged as one call because that point is hit constantly in coroutine-heavy code.