# Test evidence examples: what one recorded run proves, file by file

Dokimore documentation · Recording and self-healing · Updated 2026-11-16 · 7 min read

Written for: QA leads and test managers, Security and compliance reviewers, People evaluating or buying tools · Where it applies: every market

> Test evidence is the record that lets someone other than the tester check what a test did and why it passed or failed, without running it again. Every recorded session produces seven structured files that point at each other through stable IDs, so a failure, a security finding or a heal traces back to the exact element, request and moment. Nothing in them is guessed: a value the browser did not report is left empty.

## What test evidence is for

A pass or a fail is a claim. Evidence is what lets three different people check that claim: the developer who has to fix a failure, the QA lead who has to decide whether it is a real regression or a flaky run, and the reviewer or auditor who has to trust a result they did not watch.

Reproducible test results start from the same place: if the record says which element was used, which requests went out and what came back, a second run can be compared step by step instead of by impression.

## The seven files a recorded session produces

Each file can be downloaded on its own from the recording page, as JSON. One button downloads the whole set as a ZIP bundle: the seven files, the screenshots, the generated code and a scrubbed copy of the sign-in state, so a reviewer gets one archive rather than seven downloads.

- Element details: every element the flow touched, with typed and categorised selectors for each.
- Network data: the API calls, WebSocket messages and GraphQL operations the flow caused, with their requests and responses.
- Performance data: Core Web Vitals, cache behaviour and resource timing for the pages visited.
- Security data: cookies, headers, authentication tokens, CORS and TLS details observed during the flow.
- UI elements: size, font, visibility and link-type details of what was on screen.
- Session metadata: the browser, the starting URL, timestamps, and the registry of IDs that links the other six.
- The rerun definition: the replayable step list, which points at elements and requests by ID.

## Where the recordings live

The Recordings page lists every captured session with its steps, elements and network calls, a security-header score, and the runs it produced; a filter separates browser recordings from API-only ones, which have no browser launch and hold HTTP steps only. From the list you re-run or delete several recordings at once. Opening one shows the recorded steps in an editor (add, edit, reorder, disable or delete a step, insert a wait), the files the recording downloaded, the seven data files, the export menu and a visual playback that replays the steps in a browser on the server with a screenshot after each step.

Deleting a recording removes its runs, its download evidence and its place in any upload file it used; a file in Test Files that nothing else uses is released. The deletion is final, and the list asks before it deletes.

## How the files point at each other

Elements, requests and cookies carry stable IDs such as elem_0001, req_0001 and cookie_001. A file that needs another file’s data refers to it by ID instead of copying it, so the security file can name the request that set a cookie, and a replay step can name the element it clicks.

The format only grows: new fields are added, existing fields and IDs are kept, so evidence recorded today stays readable by later versions of the platform.

## What a failed step shows

That is usually enough to tell a changed page from a slow service from a broken test, which is the first decision in any failure analysis.

- The step and the element it targeted, with every locator that was available for that element.
- The network calls the step caused, by request ID, with their status and timing.
- The assertion and what was found instead.
- A screenshot of the page at that moment.

## Evidence for heals and security findings

A rescued step keeps its own record: the locator that failed, the one that matched and the strategy that found it, shown in the run detail. A security finding is reported as confirmed only with the request that proved it, the response, and a proof that reproduces it, linked back to the recorded request it came from.

## What is redacted, and what is never guessed

A recording captures what the browser sees, including what was typed. A login typed during a recording is kept, encrypted with AES-256-GCM, so the replay can sign in, and passwords are hidden in recording views, exports and generated test code. Make recordings with test accounts and synthetic data.

When a value cannot be determined from the browser, the field is left empty rather than estimated. Evidence with a plausible guess in it is worse than evidence with a gap, because the gap is visible.

## Limits

- Evidence shows what happened in the flows that were recorded. It does not show that untested paths work.
- A screenshot and a request log explain a failure; they do not fix it, and a judgement about whether the page is wrong or the test is wrong is still a person’s.

## Questions people ask about this

### What is test evidence?

The record that lets someone check what a test did and why it passed or failed without running it again: the elements used, the requests made and their responses, the assertion results and screenshots, linked to one another.

### Can I get the files out of the platform?

Yes. Each of the seven files downloads from the recording page as JSON, and a recording also exports as Playwright, Selenium, Robot Framework or pytest code.

This guide is about the test evidence every run keeps, and what it does not show: https://dokimore.com/product/test-evidence

Source: https://dokimore.com/documentation/test-evidence
