At a hosted browser provider, sessions from your driving-test booking suite carry no verdict — what are the causes?

## First, rule out the dull explanation Before diagnosing your harness, establish that the verdict really is absent. An annotation you sent successfully can still be invisible to you: you are signed in to a different account from the one the pipeline uses, you are filtering on a case name your code normalises differently from the way you typed it, or the window you are looking at does not contain the run. It costs nothing to eliminate, and it is the most common first cause. Once that is out of the way, a missing verdict has three shapes. ## Skipped: the call never ran The reporting code exists and was not reached. Common routes: - the case failed where the reporting path does not cover — in setup, inside a fixture, in a data-loading step that runs before the wrapper that would have reported; - an early return, a guard clause or a branch that quietly skips the report; - the case was filtered out or abandoned after the session had already been created, so a session exists and no outcome was ever computed for it; - a parallel worker exited while holding cases whose reporting had not happened yet; - the annotation sits behind a flag that is on locally and off in this pipeline. What you observe is a session with no outcome attached, which reads as an unfinished run — and that reading is usually wrong: the test finished perfectly well and the report did not. ## Refused: the call ran and was rejected Your code did its job and the far side said no. The plausible causes all follow from this being a **different call on a different channel** from the one that drove the browser: - it authenticates with a credential that is not the one the session used, or one rotated between the pipeline reading its secret and the call being made; - the payload is not acceptable — a field too long, a name carrying characters the service will not store, a verdict value it does not recognise; - it names a session the service will no longer accept an annotation for; - the account is being throttled because a wide run fired its annotations in a burst. The important operational point: **a refusal is information, and it is only yours if you kept it.** A reporting call wrapped in a bare catch that logs nothing turns a refusal into the same silence as a skip, and you have thrown away the one distinguishing signal you had. ## Lost: the process died holding the verdict The verdict was decided and the process stopped before it left: a cancelled job, a runner reclaimed mid-run, a hard kill on a timeout, an out-of-memory death. This is the worst of the three because **it is the shape in which a case that passed leaves the same trace as one that never ran.** The other two usually leave something on your side — a log line, a stack, an exit code. A killed process takes both records at once. A variant catches experienced people: the verdict is sent from a cleanup block, and that block is not a guarantee. It runs while an exception unwinds the stack; it does not run when the process is terminated from outside, when the runtime is halted directly, or when the thread is still blocked in a call that never returns. ## What the absence actually tells you | You observe | You may conclude | You must establish separately | |---|---|---| | session present, no verdict | your reporting path did not complete | whether the case passed | | verdict present, disagrees with your report | the two were written at different moments | which one is later | | no session at all | no session was created under this account | whether the case ran elsewhere | The discipline worth taking away: **a missing verdict is evidence about the reporting path, not about the test.** Reading it as a failure is as wrong as reading it as a pass. ## Making the three distinguishable Instrument your own side so the shapes separate without guesswork: 1. **Count attempts and acknowledgements separately.** Skipped then shows as no attempt, refused as an attempt with no acknowledgement. 2. **Reconcile at the end of the run.** Compare the cases executed against the annotations acknowledged and print the difference, so a run that under-reports says so out loud. 3. **Log every refusal at warning level with the case name and the reason** — never at debug, never swallowed. Cheapest change, largest diagnostic payoff. 4. **Write the verdict locally first, then push it.** A killed process then loses the push rather than the fact. 5. **Do not retry without a bound**, or a provider-side wobble becomes a suite that runs far longer than it should and still reports nothing. ## And the judgement call Decide deliberately whether a suite should fail when annotations go missing. Failing makes the reporting path a first-class dependency of every run — honest, occasionally infuriating. Not failing keeps runs green and relies on someone reading the reconciliation line. Either is defensible; drifting into the second because a catch block was empty is not.