qa-test-reporting
Test reporting + coverage analytics: 15 skills - parsers (junit-xml-analysis, lcov-analysis, cobertura-analysis, allure-reports), build-an-X reporters (coverage-diff-reporter, test-run-summary-author), commercial integrations (extentreports, currents-integration, testrail-integration, xray-integration, zephyr-integration), per-language coverage analyzers (jest-coverage-analysis, jacoco-analysis, coverage-py-analysis), and unit-test-coverage-targeter - plus 2 agents (daily-test-suite-aggregator, release-quality-report-agent).
Install this plugin
/plugin install qa-test-reporting@testland-qaPart of role bundles: qa-starter, qa-role-manual-tester, qa-role-leadership
qa-test-reporting
Test reporting + coverage analytics: per-format parsers (JUnit XML, LCOV, Cobertura, Allure), build-an-X PR reporters (coverage delta, run-summary narrative), commercial test-management integrations (Currents, TestRail, Xray, Zephyr), per-language coverage analyzers (Jest, JaCoCo, coverage.py), and a risk-weighted coverage-targeting heuristic.
Components
| Type | Name | Description |
|---|---|---|
| Skill | junit-xml-analysis | Parse JUnit-format XML; per-suite + per-case metrics; flaky vs new failure distinction via <rerunFailure> / <flakyFailure>; cross-run trend analysis. |
| Skill | lcov-analysis | Parse LCOV .info; per-file line / function / branch metrics; baseline diff + per-file gating. |
| Skill | cobertura-analysis | Parse Cobertura XML (coverage-04.dtd); per-class line + branch + complexity; cross-tool normalization. |
| Skill | allure-reports | Configure Allure adapter + CLI + history retention + categories.json failure classification + severity / epic / feature labels. |
| Skill | coverage-diff-reporter | Build-an-X PR comment with per-file coverage delta vs main; sticky-comment update; new / regressed / improved / deleted classification. |
| Skill | extentreports | Configure ExtentReports v5 (ExtentSparkReporter) for Java / .NET; log levels, screenshots, hierarchical tests, categories. |
| Skill | currents-integration | Wire Currents.dev test analytics into Playwright (@currents/playwright); record-key + project-id config; trace / video / screenshot streaming. |
| Skill | testrail-integration | Sync test runs / results to TestRail via add_run + batched add_results_for_cases; case-ID-in-test-name mapping; status convention. |
| Skill | xray-integration | Sync to Xray for Jira (Cloud / Server); JWT auth; /api/v2/import/execution/{junit,cucumber,nunit,testng,robot} endpoints; @XrayTest(key=...) mapping. |
| Skill | zephyr-integration | Sync to Zephyr Scale Cloud (post Squad/Enterprise variant disambiguation); Test Cycle + per-execution post; folder + label organization. |
| Skill | jest-coverage-analysis | Configure Jest coverageProvider (babel/v8), coverageReporters (lcov/cobertura/json/html), per-file coverageThreshold, collectCoverageFrom. |
| Skill | jacoco-analysis | Configure JaCoCo for JVM; agent + report + check goals; six counters; rule structure (element / counter / value / minimum); LCOV / Cobertura conversion. |
| Skill | coverage-py-analysis | Configure coverage.py for Python; coverage run + combine for parallel; .coveragerc source / omit / branch / fail_under; xml / lcov / json / html output. |
| Skill | unit-test-coverage-targeter | Build-an-X risk-weighted "what to test next" recommendation; cyclomatic complexity + churn for risk; pyramid layer for cost; top 5 - 10 targets. |
| Skill | test-run-summary-author | Build-an-X narrative drafter: takes a JUnit / Allure / TestRail-API run + release context, emits status-update / release-notes / exec-summary / cross-run-trend markdown with a citation appendix. |
| Agent | daily-test-suite-aggregator | Action-taking: ingests CI artifacts across multiple suites and environments for a configurable window, emits a unified (suite × environment) cell-matrix roll-up plus comparison-to-yesterday for stand-up reading. |
| Agent | release-quality-report-agent | Evidence-backed release go/no-go report (test-run summary + coverage diff + targets) for managers. |
Install
/plugin marketplace add testland/qa
/plugin install qa-test-reporting@testland-qaSkills
allure-reports
Configures Allure Report for the project (test-runner adapter installation, `allure-results` directory wiring, `categories.json` for failure classification, `history-trend.json` retention via the copy-history-between-runs pattern), runs the Allure CLI to convert `allure-results` to a static HTML site, and uploads the report as a CI artifact. Use when the team needs richer test reporting than JUnit XML - step-level attachments, per-test history, retry tracking, and severity / epic / feature labeling - across the framework-agnostic adapter ecosystem (pytest, Jest, JUnit, TestNG, NUnit, Mocha, etc.).
cobertura-analysis
Parses Cobertura XML coverage reports (the JVM-canonical format originally from the cobertura-cobertura tool, also emitted by JaCoCo `--coverage-xml`, coverage.py `--xml`, Istanbul / Jest `cobertura` reporter, gocover-cobertura, and dotnet's `coverlet`). Walks the coverage-04 DTD structure (coverage → packages → classes → methods → lines + conditions), computes per-file deltas, and emits PR-time gating verdicts. Use when the existing CI emits Cobertura XML - typical for JVM-heavy stacks and tools that ship Cobertura as a default reporter.
coverage-diff-reporter
Builds a per-PR coverage delta report from any pair of LCOV / Cobertura / JSON coverage outputs (current run + baseline from the merge target) - emits a per-file table with line% / branch% deltas, called-out new files, hidden drops (overall +0.1pp but one file -8pp), and a single-line PR-comment summary. Use when the team has coverage in CI but needs human-readable PR feedback that points at the specific file the reviewer should focus on, not just an aggregate number.
coverage-py-analysis
Configures coverage.py for Python projects - wires `coverage run` (replacing `python` for instrumentation), enables branch coverage via the `--branch` flag or `branch = True` config, manages the `.coverage` data file (single-process and `combine` for parallel pytest-xdist runs), authors `.coveragerc` with `source` / `omit` / `fail_under`, and emits the format the downstream tool needs (`coverage report` for terminal, `coverage xml` for Cobertura, `coverage html` for human review, `coverage lcov` for SaaS, `coverage json` for programmatic post-processing). Use for any Python test stack (pytest, unittest, nose) that needs PR-time coverage signal.
currents-integration
Wires Currents.dev test analytics into a Playwright test run - installs `@currents/playwright`, authors a `currents.config.ts` with `recordKey` (env-sourced) and `projectId`, registers `currentsReporter()` in `playwright.config.ts`, enables `trace: "on" / video: "on" / screenshot: "on"` artifacts, and runs via `npx pwc` (Currents-aware Playwright wrapper) so per-test traces / videos / screenshots stream to the Currents dashboard with longitudinal trends. Use when a Playwright suite needs over-time test-suite-health analytics ("test suite over time, and more") that the per-run HTML reporter can''''t provide.
extentreports
Configures ExtentReports v5 for Java / .NET test runs - wires `ExtentSparkReporter` (HTML), `attachReporter`, `createTest`, the log-level chain (`info`/`pass`/`warning`/`skip`/`fail`), screenshots via `MediaEntityBuilder`, hierarchical `createNode` parent/child tests, and category / author / device labels. Outputs a static HTML report alongside JUnit XML for CI artifact upload. Use when a JVM project (or .NET via `extentreports-dotnet`) wants a richer per-test report than JUnit XML and the team is on the Aventstack ExtentReports stack.
jacoco-analysis
Configures JaCoCo for JVM projects (Java / Kotlin / Scala / Groovy) - wires the runtime agent via `jacoco-maven-plugin` `prepare-agent`, generates per-build reports (HTML / XML / CSV) via the `report` goal, gates the build via the `check` goal with element / limit / minimum rules, parses the six native counters (instructions, branches, lines, methods, classes, cyclomatic complexity), and converts JaCoCo XML to LCOV / Cobertura when downstream tools need a different format. Use when the JVM build is Maven / Gradle and the team wants the canonical JVM coverage tool - or to convert JaCoCo output for cross-language coverage aggregation.
jest-coverage-analysis
Configures Jest's built-in coverage (Istanbul-instrumented `babel` provider or V8-native `v8` provider), wires the right `coverageReporters` for downstream consumption (`lcov` for SaaS / cross-tool, `cobertura` for Jenkins, `text-summary` for terminal, `html` for human review), authors per-file `coverageThreshold` rules that focus the gate on critical paths (vs the global-only foot-gun), and parses the per-file JSON output for PR-time deltas. Use when the project tests with Jest (or Vitest, which uses the same Istanbul/V8 provider) and the team needs PR-time coverage signal that's both local-runnable and CI-gateable.
junit-xml-analysis
Parses JUnit-format XML reports (the de-facto interchange format every CI ingests - Jenkins, GitHub Actions, GitLab, Buildkite, CircleCI) into structured, machine-readable per-suite and per-case metrics tables (passed / failed / errored / skipped, time, classname, message, stack), groups failures by classname for trend analysis, and distinguishes "new failures vs flakes" by cross-referencing rerun elements (`<flakyFailure>`, `<rerunFailure>`). Use when the downstream consumer is a dashboard, script, or aggregator - not when the goal is a human-readable prose summary (use test-run-summary-author for that). Single-run, in-XML aggregation only; for cross-run cross-environment roll-ups, use daily-test-suite-aggregator.
lcov-analysis
Parses LCOV `.info` text files (the de-facto coverage interchange format produced by gcov, llvm-cov, Coverage.py via `py2lcov`, JaCoCo via `xml2lcov`, Devel::Cover, Jest via `lcov` reporter, NYC, and most others). Extracts per-file line / function / branch metrics from the canonical record keywords (TN/SF/FN/FNDA/FNF/FNH/BRDA/BRF/BRH/DA/LH/LF), computes the diff vs a baseline, and emits per-file gating verdicts. Use for PR coverage gates that don't depend on a specific language runtime.
test-run-summary-author
Build-an-X workflow that takes a structured test-run artifact (JUnit XML, Allure JSON, TestRail / Xray / Zephyr API export) plus optional release context (version, build URL, deploy target) and emits a narrative markdown summary suitable for release notes, exec status updates, or stand-up Slack posts. Distinct from the per-framework parsers in `qa-test-reporting` (junit-xml-analysis / allure-reports / coverage-diff-reporter) which produce structured tabular reports - this skill takes the same data and produces the **narrative draft** practitioners use today by pasting raw results into ChatGPT. Distinct from `e2e-test-trend-reporter` (qa-flake-triage) which reports longitudinal suite health. Use when a manager needs a draft release note or a stand-up summary from a single test run.
testrail-integration
Syncs test runs / results / cases between an automated test suite and TestRail (Gurock / Idera) - opens a Test Run for the build (`add_run`), batches per-case results back via `add_results_for_cases` (preferred over per-test `add_result_for_case` - N+1 API calls vs 1), maps the test framework's pass/fail/skip to TestRail status IDs, and attaches build URL + version + elapsed time. Use when the team uses TestRail for test management and wants automated suites to update TestRail without a human-driven copy-paste step.
unit-test-coverage-targeter
Builds a "what to test next" recommendation by combining a coverage report (LCOV / Cobertura / coverage.py JSON / Jest JSON / JaCoCo XML) with the PR's `git diff`, ranking uncovered branches by risk × cost - risk weighted by McCabe cyclomatic complexity and code-churn frequency, cost weighted by the unit-test pyramid layer (unit tests cheaper than integration than E2E). Emits a prioritized list with concrete file:line targets and the test layer recommended for each. Use when a team has the budget to write 5 - 10 new tests and needs help picking which uncovered code to target first instead of blindly chasing 100% coverage.
xray-integration
Imports CI test results into Xray for Jira - authenticates via the `client_id` + `client_secret` → JWT exchange (Cloud) or PAT / Basic (Server), posts to the format-specific `/api/v2/import/execution/*` endpoint (`/junit` for JUnit XML, `/cucumber` for Cucumber JSON, `/nunit` / `/testng` / `/robot` for the others), and maps automated test results to existing Xray Test issues via the `xray-junit-extensions` `@XrayTest(key="...")` annotation. Use when the team uses the Xray add-on (not Zephyr Scale - see zephyr-integration) to manage Test, Test Set, and Test Execution issue types in Jira and CI must keep those execution issues in sync.
zephyr-integration
Syncs automated test results to Zephyr Scale for Jira (formerly TM4J / SmartBear / Adaptavist) - picks the right product variant (Scale Cloud vs Scale Server vs Squad), authenticates via the JWT-from-API-token pattern, opens a Test Cycle for the build, batches per-test-case executions back via the `POST /testresults` endpoint, and maps automated test methods to Zephyr Test Cases via `@TestCaseKey`-style annotations or test-name parsing. Use when the team's Jira test management is Zephyr Scale (the most common Zephyr variant in 2026) and CI must keep Test Cycles in sync with automation.
Agents
daily-test-suite-aggregator
Action-taking agent that ingests test-run artifacts from multiple suites (unit, integration, E2E, contract, performance, accessibility) and multiple environments (dev, staging, prod-canary) for a single day and emits a unified cross-suite cross-environment summary suitable for the team stand-up. Distinct from `test-run-summary-author` (sister skill that narrativises a single run) and from `e2e-test-trend-reporter` (qa-flake-triage; longitudinal weekly health for one E2E suite). Use as the morning routine that answers "how did everything we run yesterday actually go?" in one report.
release-quality-report-agent
Action-taking agent that assembles an evidence-backed release-quality go/no-go report for QA managers and heads of engineering by composing a test-run narrative, a per-file coverage diff, and risk-ranked coverage targets into a single manager-facing document with an explicit GO / NO-GO / CONDITIONAL verdict. Distinct from `daily-test-suite-aggregator` (daily standup roll-up across all suites and environments for the team) and from `test-run-summary-author` (narrative skill for a single test run, not a cross-signal verdict). Use when a release candidate build exists and a QA manager or head of engineering needs a defensible, traceable go/no-go recommendation before approving the release.