Playwright Test Results

Playwright Test Results (DuckDB)

A single DuckDB file holds recent Playwright CI test results, so you can answer

questions about failures, flakiness, and slow tests with plain SQL. It is

refreshed every few hours.

Get the database

Download the latest snapshot:

npm ci                       # first time only, from the repo root
GITHUB_TOKEN=$(gh auth token) node utils/test-results-db/cli.ts download

The snapshot may be missing the newest runs. To top it up locally, run update:

GITHUB_TOKEN=$(gh auth token) node utils/test-results-db/cli.ts update --lookback-days 3

Query it through the bundled @duckdb/node-api binding — no separate DuckDB

install needed, it ships in node_modules after npm ci:

node --input-type=module -e '
import { DuckDBInstance } from "@duckdb/node-api";
const conn = await (await DuckDBInstance.create("utils/test-results-db/test-results.duckdb")).connect();
console.table((await conn.runAndReadAll(process.argv[1])).getRowObjectsJson());
' "SELECT count(*) FROM test_results"

Integer columns come back as strings (JSON-safe), so do ranking and filtering

in SQL, not in JS.

Schema

Single table test_results, one row per test result (one row per retry).

The columns are inferred from the parquet the reporter emits

(tests/config/parquetReporter.ts), plus two trailing columns this CLI adds:

| Column | Meaning |

| --- | --- |

| run_id, run_attempt | GitHub Actions run identity |

| run_started_at | when the run started |

| workflow_name | e.g. tests 1 / tests 2 / tests others / MCP |

| event | push / pull_request |

| head_sha, head_branch, pr_number | what was tested |

| bot_name | e.g. chromium-ubuntu-22.04-node20, webkit-macos-15-large — the CI bot. OS and arch are encoded here; there is no separate os column. |

| project_name | CI project = browser + suite, e.g. chromium-page, webkit-library, playwright-test |

| test_title | title path within the file, joined by › (describe › test) |

| file, line, column_number | source location (file is relative to repo root) |

| expected_status | passed / skipped / ... |

| status | actual result: passed / failed / timedOut / skipped / interrupted |

| retry | 0 = first attempt |

| result_started_at | when this attempt started |

| duration_ms | result duration |

| error_message | all errors joined, ANSI-stripped (NULL when none) |

| tags | list of strings, e.g. ['@slow', '@flaky'] (use list functions / list_contains) |

| annotations | list of {type, description} structs, e.g. [{'type': 'skip', 'description': 'flaky on CI'}] (empty list when none) |

| artifact_id | the GitHub artifact this row came from (dedupe key) |

| ingested_at | debug only — when this row was imported |

Notes:

• A test is identified by (project_name, file, test_title) — group on that

tuple. (Playwright's test_id hash is deliberately not stored; those three

columns are its pre-image.)

• Flakiness is derived, not stored. The signal that matters most is

cross-run: a test whose *final* verdict (after retries) flips between

runs — green in some, red in others. A separate within-run flake is a

test a retry rescued inside a single run (failed→passed).

• Real failures vs intentional ones: filter expected_status = 'passed'.

Tests marked test.fail() record status='failed' *with*

expected_status='failed' and would otherwise dominate any "most failing" list.

• The db is size-capped by run count: the oldest whole runs are evicted over

time, so it holds a recent window, not full history.

Example queries

Group tests by (project_name, file, test_title) and (for failure/flakiness)

scope to expected_status = 'passed' so intentional test.fail() tests don't

skew the results.

Flaky across runs — the test's final verdict flips between runs (this is

what makes a red CI run ambiguous). least(failed_runs, passed_runs) ranks

genuinely bimodal tests above both always-broken and one-off failures:

WITH per_run AS (
  SELECT project_name, file, test_title, run_id, run_attempt,
         arg_max(status, retry) AS final_status,
         any_value(expected_status) AS expected
  FROM test_results
  GROUP BY project_name, file, test_title, run_id, run_attempt)
SELECT project_name, test_title,
       count(*) AS runs,
       count(*) FILTER (WHERE final_status IN ('failed','timedOut')) AS failed_runs,
       count(*) FILTER (WHERE final_status = 'passed') AS passed_runs,
       round(100.0 * count(*) FILTER (WHERE final_status IN ('failed','timedOut'))
             / count(*), 1) AS fail_pct
FROM per_run
WHERE expected = 'passed'
GROUP BY project_name, test_title
HAVING failed_runs > 0 AND passed_runs > 0 AND runs >= 10
ORDER BY least(failed_runs, passed_runs) DESC, failed_runs DESC
LIMIT 20;

Filter by tag (tags is a list, not a string):

SELECT project_name, test_title, count(*) AS runs
FROM test_results
WHERE list_contains(tags, '@slow')
GROUP BY project_name, test_title
ORDER BY runs DESC
LIMIT 20;

Generate a linked emoji run history

For a compact result that drops straight into a GitHub comment, render each

final run verdict as a linked square. Edit the four test identity fields, then

run:

node --input-type=module <<'EOF'
import { DuckDBInstance } from "@duckdb/node-api";

const repository = "microsoft/playwright";
const test = {
  projectName: "firefox-library",
  file: "library/proxy.spec.ts",
  testTitle: "should exclude patterns",
  botName: "firefox-macos-15-large",
};

const conn = await (await DuckDBInstance.create(
  "utils/test-results-db/test-results.duckdb"
)).connect();
const result = await conn.runAndReadAll(`
  WITH per_run AS (
    SELECT run_id, run_attempt,
           any_value(run_started_at) AS run_started_at,
           arg_max(status, retry) AS final_status,
           arg_max(expected_status, retry) AS expected_status,
           list(status ORDER BY retry) AS attempt_statuses
    FROM test_results
    WHERE project_name = $projectName
      AND file = $file
      AND test_title = $testTitle
      AND bot_name = $botName
    GROUP BY run_id, run_attempt
  )
  SELECT run_id, run_attempt, final_status, attempt_statuses
  FROM per_run
  WHERE expected_status = 'passed'
    AND final_status IN ('passed', 'failed', 'timedOut')
  ORDER BY run_started_at, run_id, run_attempt
`, test);

const markdown = result.getRowObjectsJson().map(row => {
  const rescued = row.final_status === "passed" &&
    row.attempt_statuses.some(status => status === "failed" || status === "timedOut");
  const emoji = rescued ? "🟧" : row.final_status === "passed" ? "🟩" : "🟥";
  const url = `https://github.com/${repository}/actions/runs/${row.run_id}/attempts/${row.run_attempt}`;
  return `[${emoji}](${url})`;
}).join("");

console.log(markdown);
EOF

The output is Markdown:

[🟩](https://github.com/microsoft/playwright/actions/runs/123/attempts/1)[🟧](https://github.com/microsoft/playwright/actions/runs/456/attempts/1)[🟥](https://github.com/microsoft/playwright/actions/runs/789/attempts/1)

Each square is one workflow run attempt, oldest first. Green means passed,

orange means a retry rescued an earlier failure, and red means failed or timed

out. arg_max(status, retry) picks the final verdict after retries, while

grouping by (run_id, run_attempt) keeps retries from turning into extra

squares. The /attempts/<n> URL links to the exact rerun that produced the

result.

Fetching the full detail

The db stores per-result summaries. For the full step tree / attachments / stdio,

fetch the original blob report for that run, if the run uploaded one. A row

identifies it by run_id + bot_name: the run's blob artifact is named

blob-report-<bot_name>.

# List the run's blob artifacts and find the one for this bot_name:
gh api /repos/microsoft/playwright/actions/runs/<run_id>/artifacts \
  --jq '.artifacts[] | select(.name | startswith("blob-report")) | {id, name}'

# Download it (name == "blob-report-<bot_name>"):
gh api /repos/microsoft/playwright/actions/artifacts/<artifact_id>/zip > blob.zip

Blob and parquet artifacts have a 7-day retention, so this works only for recent

runs; the db itself retains summaries longer (until run-count eviction).