From be98dd61018e41f37e107c3aa926966f635b2566 Mon Sep 17 00:00:00 2001 From: zacharyburnett Date: Tue, 24 Feb 2026 09:46:01 -0500 Subject: [PATCH] add option to generate test coverage report without codecov MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Stuart Mumford Co-authored-by: Clément Robert --- .github/workflows/test_tox.yml | 8 ++++++ .github/workflows/tox.yml | 50 ++++++++++++++++++++++++++++++++-- docs/source/tox.rst | 4 +-- pyproject.toml | 5 ++++ tools/tox_matrix.py | 13 +++++---- tox.ini | 5 ++++ 6 files changed, 75 insertions(+), 10 deletions(-) diff --git a/.github/workflows/test_tox.yml b/.github/workflows/test_tox.yml index c7f7b809..f5174aa2 100644 --- a/.github/workflows/test_tox.yml +++ b/.github/workflows/test_tox.yml @@ -158,6 +158,14 @@ jobs: a/ cache-key: cache-${{ github.run_id }} + test_coverage_github: + uses: ./.github/workflows/tox.yml + with: + coverage: github + envs: | + - linux: py313-covcheck + - linux: py314-covcheck + test_artifact_upload: uses: ./.github/workflows/tox.yml with: diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 9884b1c1..c05bfc75 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -117,15 +117,13 @@ jobs: envs: name: Load tox environments runs-on: ubuntu-latest - outputs: - matrix: ${{ steps.set-outputs.outputs.matrix }} steps: - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0 with: python-version: '3.12' - run: echo $TOX_MATRIX_SCRIPT | base64 --decode > tox_matrix.py env: - TOX_MATRIX_SCRIPT: # /// script
# requires-python = "==3.12"
# dependencies = [
#     "click==8.2.1",
#     "pyyaml==6.0.2",
# ]
# ///
import json
import os
import re

import click
import yaml


@click.command()
@click.option("--envs", default="")
@click.option("--libraries", default="")
@click.option("--posargs", default="")
@click.option("--toxdeps", default="")
@click.option("--toxargs", default="")
@click.option("--pytest", default="true")
@click.option("--pytest-results-summary", default="false")
@click.option("--coverage", default="")
@click.option("--conda", default="auto")
@click.option("--setenv", default="")
@click.option("--display", default="false")
@click.option("--cache-path", default="")
@click.option("--cache-key", default="")
@click.option("--cache-restore-keys", default="")
@click.option("--artifact-path", default="")
@click.option("--runs-on", default="")
@click.option("--default-python", default="")
@click.option("--timeout-minutes", default="360")
def load_tox_targets(envs, libraries, posargs, toxdeps, toxargs, pytest, pytest_results_summary,
                     coverage, conda, setenv, display, cache_path, cache_key,
                     cache_restore_keys, artifact_path, runs_on, default_python, timeout_minutes):
    """Script to load tox targets for GitHub Actions workflow."""
    # Load envs config
    envs = yaml.load(envs, Loader=yaml.BaseLoader)
    print(json.dumps(envs, indent=2))

    # Load global libraries config
    global_libraries = {
        "brew": [],
        "brew-cask": [],
        "apt": [],
        "choco": [],
    }
    libraries = yaml.load(libraries, Loader=yaml.BaseLoader)
    if libraries is not None:
        global_libraries.update(libraries)
    print(json.dumps(global_libraries, indent=2))

    # Default images to use for runners
    default_runs_on = {
        "linux": "ubuntu-latest",
        "macos": "macos-latest",
        "windows": "windows-latest",
    }
    custom_runs_on = yaml.load(runs_on, Loader=yaml.BaseLoader)
    if isinstance(custom_runs_on, dict):
        default_runs_on.update(custom_runs_on)
    print(json.dumps(default_runs_on, indent=2))

    # Default string parameters which can be overwritten by each env
    string_parameters = {
        "posargs": posargs,
        "toxdeps": toxdeps,
        "toxargs": toxargs,
        "pytest": pytest,
        "pytest-results-summary": pytest_results_summary,
        "coverage": coverage,
        "conda": conda,
        "setenv": setenv,
        "display": display,
        "cache-path": cache_path,
        "cache-key": cache_key,
        "cache-restore-keys": cache_restore_keys,
        "artifact-path": artifact_path,
        "timeout-minutes": timeout_minutes,
    }

    # Create matrix
    matrix = {"include": []}
    for env in envs:
        matrix["include"].append(get_matrix_item(
            env,
            global_libraries=global_libraries,
            global_string_parameters=string_parameters,
            runs_on=default_runs_on,
            default_python=default_python,
        ))

    # Output matrix
    print(json.dumps(matrix, indent=2))
    with open(os.environ["GITHUB_OUTPUT"], "a") as f:
        f.write(f"matrix={json.dumps(matrix)}\n")


def get_matrix_item(env, global_libraries, global_string_parameters,
                    runs_on, default_python):

    # define spec for each matrix include (+ global_string_parameters)
    item = {
        "os": None,
        "toxenv": None,
        "python_version": None,
        "name": None,
        "pytest_flag": None,
        "libraries_brew": None,
        "libraries_brew_cask": None,
        "libraries_apt": None,
        "libraries_choco": None,
        "cache-path": None,
        "cache-key": None,
        "cache-restore-keys": None,
        "artifact-name": None,
        "artifact-path": None,
        "timeout-minutes": None,
    }
    for string_param, default in global_string_parameters.items():
        env_value = env.get(string_param)
        item[string_param] = default if env_value is None else env_value

    # set os and toxenv
    for k, v in runs_on.items():
        if k in env:
            platform = k
            item["os"] = env.get("runs-on", v)
            item["toxenv"] = env[k]
    assert item["os"] is not None and item["toxenv"] is not None

    # set python_version
    python_version = env.get("python-version")
    m = re.search("^py(2|3)([0-9]+t?)", item["toxenv"])
    if python_version is not None:
        item["python_version"] = python_version
    elif m is not None:
        major, minor = m.groups()
        item["python_version"] = f"{major}.{minor}"
    else:
        item["python_version"] = env.get("default_python") or default_python

    # set name
    item["name"] = env.get("name") or f'{item["toxenv"]} ({item["os"]})'

    # set artifact-name (replace invalid path characters)
    item["artifact-name"] = re.sub(r"[\\ /:<>|*?\"']", "-", item["name"])
    item["artifact-name"] = re.sub(r"-+", "-", item["artifact-name"])

    # set pytest_flag
    item["pytest_flag"] = ""
    sep = r"\\" if platform == "windows" else "/"
    if item["pytest"] == "true" and "codecov" in item.get("coverage", ""):
        item["pytest_flag"] += (
            rf"--cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml ")
    if item["pytest"] == "true" and item["pytest-results-summary"] == "true":
        item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml "

    # set libraries
    env_libraries = env.get("libraries")
    if isinstance(env_libraries, str) and len(env_libraries.strip()) == 0:
        env_libraries = {}  # no libraries requested for environment
    libraries = global_libraries if env_libraries is None else env_libraries
    for manager in ["brew", "brew_cask", "apt", "choco"]:
        item[f"libraries_{manager}"] = " ".join(libraries.get(manager, []))

    # set "auto" conda value
    if item["conda"] == "auto":
        item["conda"] = "true" if "conda" in item["toxenv"] else "false"

    # inject toxdeps for conda
    if item["conda"] == "true" and "tox-conda" not in item["toxdeps"].lower():
        item["toxdeps"] = ("tox-conda " + item["toxdeps"]).strip()

    # make timeout-minutes a number
    item["timeout-minutes"] = int(item["timeout-minutes"])

    # verify values
    assert item["pytest"] in {"true", "false"}
    assert item["conda"] in {"true", "false"}
    assert item["display"] in {"true", "false"}

    return item


if __name__ == "__main__":
    load_tox_targets()
 + TOX_MATRIX_SCRIPT: # /// script
# requires-python = "==3.12"
# dependencies = [
#     "click==8.2.1",
#     "pyyaml==6.0.2",
# ]
# ///
import json
import os
import re

import click
import yaml


@click.command()
@click.option("--envs", default="")
@click.option("--libraries", default="")
@click.option("--posargs", default="")
@click.option("--toxdeps", default="")
@click.option("--toxargs", default="")
@click.option("--pytest", default="true")
@click.option("--pytest-results-summary", default="false")
@click.option("--coverage", default="")
@click.option("--conda", default="auto")
@click.option("--setenv", default="")
@click.option("--display", default="false")
@click.option("--cache-path", default="")
@click.option("--cache-key", default="")
@click.option("--cache-restore-keys", default="")
@click.option("--artifact-path", default="")
@click.option("--runs-on", default="")
@click.option("--default-python", default="")
@click.option("--timeout-minutes", default="360")
def load_tox_targets(envs, libraries, posargs, toxdeps, toxargs, pytest, pytest_results_summary,
                     coverage, conda, setenv, display, cache_path, cache_key,
                     cache_restore_keys, artifact_path, runs_on, default_python, timeout_minutes):
    """Script to load tox targets for GitHub Actions workflow."""
    # Load envs config
    envs = yaml.load(envs, Loader=yaml.BaseLoader)
    print(json.dumps(envs, indent=2))

    # Load global libraries config
    global_libraries = {
        "brew": [],
        "brew-cask": [],
        "apt": [],
        "choco": [],
    }
    libraries = yaml.load(libraries, Loader=yaml.BaseLoader)
    if libraries is not None:
        global_libraries.update(libraries)
    print(json.dumps(global_libraries, indent=2))

    # Default images to use for runners
    default_runs_on = {
        "linux": "ubuntu-latest",
        "macos": "macos-latest",
        "windows": "windows-latest",
    }
    custom_runs_on = yaml.load(runs_on, Loader=yaml.BaseLoader)
    if isinstance(custom_runs_on, dict):
        default_runs_on.update(custom_runs_on)
    print(json.dumps(default_runs_on, indent=2))

    # Default string parameters which can be overwritten by each env
    string_parameters = {
        "posargs": posargs,
        "toxdeps": toxdeps,
        "toxargs": toxargs,
        "pytest": pytest,
        "pytest-results-summary": pytest_results_summary,
        "coverage": coverage,
        "conda": conda,
        "setenv": setenv,
        "display": display,
        "cache-path": cache_path,
        "cache-key": cache_key,
        "cache-restore-keys": cache_restore_keys,
        "artifact-path": artifact_path,
        "timeout-minutes": timeout_minutes,
    }

    # Create matrix
    matrix = {"include": []}
    for env in envs:
        matrix["include"].append(get_matrix_item(
            env,
            global_libraries=global_libraries,
            global_string_parameters=string_parameters,
            runs_on=default_runs_on,
            default_python=default_python,
        ))

    # Output matrix
    print(json.dumps(matrix, indent=2))
    with open(os.environ["GITHUB_OUTPUT"], "a") as f:
        f.write(f"matrix={json.dumps(matrix)}\n")


def get_matrix_item(env, global_libraries, global_string_parameters,
                    runs_on, default_python):

    # define spec for each matrix include (+ global_string_parameters)
    item = {
        "os": None,
        "toxenv": None,
        "python_version": None,
        "name": None,
        "pytest_flag": None,
        "libraries_brew": None,
        "libraries_brew_cask": None,
        "libraries_apt": None,
        "libraries_choco": None,
        "cache-path": None,
        "cache-key": None,
        "cache-restore-keys": None,
        "artifact-name": None,
        "artifact-path": None,
        "timeout-minutes": None,
    }
    for string_param, default in global_string_parameters.items():
        env_value = env.get(string_param)
        item[string_param] = default if env_value is None else env_value

    # set os and toxenv
    for k, v in runs_on.items():
        if k in env:
            platform = k
            item["os"] = env.get("runs-on", v)
            item["toxenv"] = env[k]
    assert item["os"] is not None and item["toxenv"] is not None

    # set python_version
    python_version = env.get("python-version")
    m = re.search("^py(2|3)([0-9]+t?)", item["toxenv"])
    if python_version is not None:
        item["python_version"] = python_version
    elif m is not None:
        major, minor = m.groups()
        item["python_version"] = f"{major}.{minor}"
    else:
        item["python_version"] = env.get("default_python") or default_python

    # set name
    item["name"] = env.get("name") or f'{item["toxenv"]} ({item["os"]})'

    # set artifact-name (replace invalid path characters)
    item["artifact-name"] = re.sub(r"[\\ /:<>|*?\"']", "-", item["name"])
    item["artifact-name"] = re.sub(r"-+", "-", item["artifact-name"])

    # set pytest_flag
    item["pytest_flag"] = ""
    sep = r"\\" if platform == "windows" else "/"
    if item["pytest"] == "true":
        if "codecov" in item.get("coverage", ""):
            item["pytest_flag"] += (
                rf"--cov --cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml "
            )

        if item["pytest-results-summary"] == "true":
            item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml "

    # set libraries
    env_libraries = env.get("libraries")
    if isinstance(env_libraries, str) and len(env_libraries.strip()) == 0:
        env_libraries = {}  # no libraries requested for environment
    libraries = global_libraries if env_libraries is None else env_libraries
    for manager in ["brew", "brew_cask", "apt", "choco"]:
        item[f"libraries_{manager}"] = " ".join(libraries.get(manager, []))

    # set "auto" conda value
    if item["conda"] == "auto":
        item["conda"] = "true" if "conda" in item["toxenv"] else "false"

    # inject toxdeps for conda
    if item["conda"] == "true" and "tox-conda" not in item["toxdeps"].lower():
        item["toxdeps"] = ("tox-conda " + item["toxdeps"]).strip()

    # make timeout-minutes a number
    item["timeout-minutes"] = int(item["timeout-minutes"])

    # verify values
    assert item["pytest"] in {"true", "false"}
    assert item["conda"] in {"true", "false"}
    assert item["display"] in {"true", "false"}

    return item


if __name__ == "__main__":
    load_tox_targets()
 - run: cat tox_matrix.py - id: set-outputs run: | @@ -141,6 +139,8 @@ jobs: --runs-on "${{ inputs.runs-on }}" --default-python "${{ inputs.default_python }}" \ --timeout-minutes "${{ inputs.timeout-minutes }}" shell: sh + outputs: + matrix: ${{ steps.set-outputs.outputs.matrix }} tox: name: ${{ matrix.name }} @@ -236,3 +236,47 @@ jobs: uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2 with: token: ${{ secrets.CODECOV_TOKEN }} + + - name: Upload coverage data to GitHub + id: upload-coverage-gh + if: ${{ (success() || failure()) && contains(matrix.coverage, 'github') && matrix.pytest == 'true' }} + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 + with: + name: coverage-data-${{ github.run_id }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} + path: .coverage.* + if-no-files-found: error + include-hidden-files: true + outputs: + coverage-gh: ${{ steps.upload-coverage-gh.outputs.artifact-id }} + + report_overall_test_coverage: + needs: [ tox ] + if: needs.tox.outputs.coverage-gh + name: report overall test coverage + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 + with: + lfs: true + submodules: ${{ inputs.submodules }} + ref: ${{ inputs.checkout_ref }} + - uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0 + with: + pattern: coverage-data-${{ github.run_id }}-* + merge-multiple: true + + - uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0 + with: + python-version: "3.12" + - name: generate coverage report + run: | + python -Im pip install 'pip>=25.1' + python -Im pip install --group covcheck + python -Im coverage combine + python -Im coverage report -i -m --format=markdown >> $GITHUB_STEP_SUMMARY + - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 + with: + name: coverage-report-${{ hashFiles('.coverage') }} + path: .coverage + if-no-files-found: error + include-hidden-files: true diff --git a/docs/source/tox.rst b/docs/source/tox.rst index f6edcb01..b61e49e4 100644 --- a/docs/source/tox.rst +++ b/docs/source/tox.rst @@ -164,8 +164,8 @@ This option has no effect if ``pytest`` is ``false``. coverage ^^^^^^^^ -A space separated list of coverage providers to upload to. Currently -only ``codecov`` is supported. Default is to not upload coverage +A space separated list of coverage providers to upload to, either +``codecov`` or ``github``. Default is to not upload coverage reports. See also, ``CODECOV_TOKEN`` secret. diff --git a/pyproject.toml b/pyproject.toml index 5dda3f19..aa6ac868 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -26,6 +26,11 @@ concurrency = [ "pytest-repeat>=0.9.3", "pytest-run-parallel>=0.4.4", ] +covcheck = [ + "coverage[toml] ; python_version < '3.11'", + "coverage>=7.11.3", + "pytest-cov>=7.0.0", +] test = [ "hypothesis>=6.113.0", "pytest>=8.3.5", diff --git a/tools/tox_matrix.py b/tools/tox_matrix.py index f10a1a83..76c3f1a2 100644 --- a/tools/tox_matrix.py +++ b/tools/tox_matrix.py @@ -152,11 +152,14 @@ def get_matrix_item(env, global_libraries, global_string_parameters, # set pytest_flag item["pytest_flag"] = "" sep = r"\\" if platform == "windows" else "/" - if item["pytest"] == "true" and "codecov" in item.get("coverage", ""): - item["pytest_flag"] += ( - rf"--cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml ") - if item["pytest"] == "true" and item["pytest-results-summary"] == "true": - item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml " + if item["pytest"] == "true": + if "codecov" in item.get("coverage", ""): + item["pytest_flag"] += ( + rf"--cov --cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml " + ) + + if item["pytest-results-summary"] == "true": + item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml " # set libraries env_libraries = env.get("libraries") diff --git a/tox.ini b/tox.ini index dd2e56e8..cfe6b406 100644 --- a/tox.ini +++ b/tox.ini @@ -7,6 +7,7 @@ envlist = py{,py}3{10,13}-python_version libraries cache-{setup,verify} + covcheck [testenv] allowlist_externals = @@ -17,6 +18,9 @@ allowlist_externals = bash rolldice which +dependency_groups = + covcheck: covcheck + covcheck: test skip_install = true passenv = MY_VAR commands = @@ -48,6 +52,7 @@ commands = artifact-upload: bash -c "echo 'hello world' > test.txt" # Verify that freethreaded builds are using freethreaded interpreter py313t: python -c "import sys; assert 'free-threading' in sys.version" + covcheck: coverage run --parallel-mode -m pytest --pyargs test_package {posargs} [testenv:pep8] description = verify pep8