# OpenHuman Code Coverage Requirement: How 80% Diff Coverage is Enforced in CI

> Discover OpenHuman's 80% code coverage requirement and how the Coverage Gate CI workflow enforces it using diff-cover to block non-compliant pull requests. Maintain code quality easily.

- Repository: [Tiny Humans/openhuman](https://github.com/tinyhumansai/openhuman)
- Tags: how-to-guide
- Published: 2026-06-16

---

**OpenHuman enforces a strict minimum 80% line-coverage requirement on all changed code through a dedicated Coverage Gate CI workflow that uses `diff-cover` to block pull requests falling below the threshold.**

The OpenHuman repository maintains high code quality standards by requiring comprehensive test coverage for every contribution. According to the project's CI configuration and documentation, all pull requests must achieve at least **80% coverage on changed lines** before they can be merged into the main branch. This requirement is enforced automatically through a multi-stage pipeline that aggregates coverage data from three distinct language stacks.

## The 80% Diff Coverage Threshold

Unlike traditional repository-wide coverage metrics, OpenHuman employs a **diff coverage** strategy. This means the 80% requirement applies specifically to the lines of code modified in a pull request, not the entire codebase. The rule is implemented in the `coverage-gate` job defined in [`.github/workflows/coverage.yml`](https://github.com/tinyhumansai/openhuman/blob/main/.github/workflows/coverage.yml).

When a developer opens a PR, the CI system generates coverage reports for the affected code and compares them against the base branch. If the calculated coverage on changed lines falls below 80%, the `diff-cover` tool exits with a failure status, preventing the merge.

## How the Coverage Gate Works

The Coverage Gate workflow orchestrates three parallel jobs to collect coverage data across the project's heterogeneous stack, then aggregates them for final validation.

### Frontend Coverage with Vitest

The TypeScript frontend stack executes `pnpm test:coverage` within the `app/` directory. This command generates an `lcov.info` file containing JavaScript/TypeScript coverage data. Before aggregation, the workflow normalizes the paths in this file to ensure they align with the repository root structure, which is required for accurate comparison by `diff-cover`.

### Rust Core and Tauri Shell

The project generates separate coverage reports for two Rust compilation units:

- **Rust core**: The workflow runs `cargo llvm-cov --no-fail-fast -p openhuman --lcov --output-path lcov-core.info` against the core crate
- **Tauri shell**: It executes `cargo llvm-cov --manifest-path app/src-tauri/Cargo.toml --lcov --output-path lcov-tauri.info` for the desktop application shell

Both commands produce LCOV-compatible files that track line-by-line execution coverage for the Rust codebase.

### The diff-cover Enforcement Step

The `coverage-gate` job downloads all three LCOV artifacts (`lcov.info`, `lcov-core.info`, and `lcov-tauri.info`) and feeds them into `diff-cover` for analysis. The critical enforcement command includes:

```yaml
- name: Enforce ≥ 80% coverage on changed lines
  run: |
    set -euo pipefail
    mapfile -t LCOV_FILES < <(find lcov-artifacts -type f -name '*.info' | sort)
    diff-cover "${LCOV_FILES[@]}" \
      --compare-branch="origin/${{ github.base_ref }}" \
      --fail-under=80 \
      --html-report diff-coverage.html \
      --markdown-report diff-coverage.md

```

The `--fail-under=80` flag institutes the hard minimum. If the coverage percentage on changed lines is 79% or lower, the job fails immediately and blocks the PR from merging. The workflow also generates HTML and markdown reports as downloadable artifacts for debugging.

## Where Requirements Are Documented

The 80% coverage requirement is codified in multiple locations to ensure visibility for contributors.

### Workflow Configuration

The authoritative implementation resides in [`.github/workflows/coverage.yml`](https://github.com/tinyhumansai/openhuman/blob/main/.github/workflows/coverage.yml), which defines the `coverage-gate` job and its dependencies on the three coverage generation steps.

### Project Documentation

The [`AGENTS.md`](https://github.com/tinyhumansai/openhuman/blob/main/AGENTS.md) file explicitly states the policy: *"PRs need ≥ 80% coverage on changed lines via `diff-cover`"*, providing human-readable context for the enforcement mechanism.

### Pull Request Template

The [`.github/PULL_REQUEST_TEMPLATE.md`](https://github.com/tinyhumansai/openhuman/blob/main/.github/PULL_REQUEST_TEMPLATE.md) includes a checklist item reminding authors to verify "Diff coverage ≥ 80%" before requesting review, ensuring the requirement remains top-of-mind during the development process.

## Running Coverage Checks Locally

Developers can verify coverage compliance before submitting a PR by generating the required LCOV files locally:

```bash

# Frontend (Vitest) - generates app/coverage/lcov.info

pnpm test:coverage

# Rust core - generates lcov-core.info

cargo llvm-cov --no-fail-fast -p openhuman --lcov --output-path lcov-core.info

# Tauri shell - generates lcov-tauri.info

cargo llvm-cov --manifest-path app/src-tauri/Cargo.toml --lcov --output-path lcov-tauri.info

```

After generating these files, run `diff-cover` locally against your feature branch to verify you meet the 80% threshold before pushing.

## Summary

- OpenHuman requires **≥ 80% line coverage on all changed code** in every pull request.
- The **Coverage Gate** workflow in [`.github/workflows/coverage.yml`](https://github.com/tinyhumansai/openhuman/blob/main/.github/workflows/coverage.yml) aggregates reports from Vitest (frontend) and `cargo llvm-cov` (Rust core and Tauri).
- **`diff-cover`** computes coverage only on modified lines and enforces the threshold via `--fail-under=80`.
- Failures appear in the GitHub Checks UI and **block merging** until coverage is improved.
- Requirements are documented in the workflow file, [`AGENTS.md`](https://github.com/tinyhumansai/openhuman/blob/main/AGENTS.md), and the pull request template.

## Frequently Asked Questions

### What is the exact code coverage requirement in OpenHuman?

The project mandates a minimum of **80% line coverage specifically on changed lines** for every pull request. This diff-coverage approach ensures new code is tested without requiring the entire repository to meet the threshold.

### How does the CI system enforce the coverage requirement?

The CI pipeline uses a `coverage-gate` job that runs `diff-cover` against three LCOV files generated by Vitest and `cargo llvm-cov`. The command includes `--fail-under=80`, which causes the job to fail if changed lines lack sufficient coverage, blocking the merge via GitHub branch protection rules.

### Can developers run coverage checks locally before submitting a PR?

Yes. Developers can generate the required LCOV files using `pnpm test:coverage` for the frontend and `cargo llvm-cov` commands for the Rust components. Running `diff-cover` locally with these files allows verification of the 80% threshold before creating a pull request.

### What happens if my pull request fails the Coverage Gate?

The GitHub Checks UI will display a failure status for the `coverage-gate` job, preventing merge until the issue is resolved. You must either add tests to increase coverage on your changed lines to at least 80% or reduce the scope of changes to meet the requirement.