From 6059407fc635496ef5a732c0f05ada8762ed4917 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 11:00:09 +0100 Subject: [PATCH 01/16] Add a test for pytest-cov with github coverage --- .github/workflows/test_tox.yml | 5 ++++- tox.ini | 4 +++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/.github/workflows/test_tox.yml b/.github/workflows/test_tox.yml index 5f135641..8e906354 100644 --- a/.github/workflows/test_tox.yml +++ b/.github/workflows/test_tox.yml @@ -162,8 +162,11 @@ jobs: with: coverage: github envs: | + # covcheck uses an explicit coverage run - linux: py313-covcheck - - linux: py314-covcheck + # Now also test it works with pytest-cov + - linux: py314 + posargs: --cov=test_package test_artifact_upload: uses: ./.github/workflows/tox.yml diff --git a/tox.ini b/tox.ini index cfe6b406..8598d260 100644 --- a/tox.ini +++ b/tox.ini @@ -62,7 +62,9 @@ commands = ruff check . [testenv:py3{10,11,12}{,-conda}] description = run pytest skip_install = false -dependency_groups = test +dependency_groups = + test + covcheck conda_deps = pytest commands = conda: python -c "import os, sys; assert os.path.exists(os.path.join(sys.prefix, 'conda-meta', 'history'))" From ad8caed27b9bd8e42eb78a400ad542258fae7718 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 11:05:30 +0100 Subject: [PATCH 02/16] Don't require suffix on .coverage file --- .github/workflows/tox.yml | 6 ++++-- tox.ini | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 2fb6ae98..85f671a5 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -210,8 +210,8 @@ jobs: run: shell: bash -l {0} working-directory: ${{ inputs.working-directory }} - steps: + steps: - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 with: fetch-depth: 0 @@ -313,7 +313,9 @@ jobs: uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: coverage-data-${{ github.run_id }}-${{ runner.os }}-${{ runner.arch }}-${{ matrix.toxenv }} - path: .coverage.* + path: | + .coverage + .coverage.* if-no-files-found: error include-hidden-files: true outputs: diff --git a/tox.ini b/tox.ini index 8598d260..1647129c 100644 --- a/tox.ini +++ b/tox.ini @@ -59,7 +59,7 @@ description = verify pep8 deps = ruff commands = ruff check . -[testenv:py3{10,11,12}{,-conda}] +[testenv:py3{10-16}{,-conda,-tmpdir}] description = run pytest skip_install = false dependency_groups = From 793a91eb1693951567822e9b2a5695b6af99dc68 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 11:21:49 +0100 Subject: [PATCH 03/16] Add a test for running in a tmpdir --- .github/workflows/test_tox.yml | 3 +++ tox.ini | 2 ++ 2 files changed, 5 insertions(+) diff --git a/.github/workflows/test_tox.yml b/.github/workflows/test_tox.yml index 8e906354..7585ceed 100644 --- a/.github/workflows/test_tox.yml +++ b/.github/workflows/test_tox.yml @@ -167,6 +167,9 @@ jobs: # Now also test it works with pytest-cov - linux: py314 posargs: --cov=test_package + # And test it works if the pytest command isn't run in the toxinidir + - linux: py314-tmpdir + posargs: --cov=test_package test_artifact_upload: uses: ./.github/workflows/tox.yml diff --git a/tox.ini b/tox.ini index 1647129c..952ddb1c 100644 --- a/tox.ini +++ b/tox.ini @@ -66,6 +66,8 @@ dependency_groups = test covcheck conda_deps = pytest +changedir = + tmpdir: .tmp/{envname} commands = conda: python -c "import os, sys; assert os.path.exists(os.path.join(sys.prefix, 'conda-meta', 'history'))" conda: micromamba list From 781f3a555a8db8ad1c3d5d738546854d77159334 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 12:00:32 +0100 Subject: [PATCH 04/16] Improve documentation around coverage --- docs/source/tox.rst | 36 +++++++++++++++++++++++++++++++----- 1 file changed, 31 insertions(+), 5 deletions(-) diff --git a/docs/source/tox.rst b/docs/source/tox.rst index 73e1340a..5d06da2c 100644 --- a/docs/source/tox.rst +++ b/docs/source/tox.rst @@ -163,13 +163,37 @@ This option has no effect if ``pytest`` is ``false``. coverage ^^^^^^^^ -A space separated list of coverage providers to upload to, either -``codecov`` or ``github``. Default is to not upload coverage -reports. +The coverage option controls how coverage reports are made and processed after the tox job has completed. +This option has no effect if ``pytest`` is ``false``. +This option takes a space separated list of coverage providers to upload to, either ``codecov`` or ``github``. +Default is to not upload coverage reports. +If using ``codecov`` see :ref:`codecov-token`. -See also, ``CODECOV_TOKEN`` secret. +As the workflows do not control how your tests are run, configuring coverage correctly may require changes to your tox.ini. +The coverage collection is done inside the tox job, but the workflows handle generating reports and uploading to either codecov or github. -This option has no effect if ``pytest`` is ``false``. +Coverage Collection +################### + +There are two main ways to generate coverage for your test run(s): + +* Using `coverage.py `__ directly, which generally means prefixing your pytest command with ``coverage run -m ``. This will generate one or more ``.coverage`` files in the current directory (for parallel jobs it can generate one per process). +* Using `pytest-cov `__ which generally involves installing ``pytest-cov`` and adding ``--cov=`` to your pytest flags, this will also generate a ``.coverage`` file in the current directory as well as reporting coverage to the terminal by default. + +Coverage Reporting +################## + +After coverage has been collected the workflows work with collected ``.coverage`` database files that should have been generated as part of your test run. +If uploading to GitHub all these reports will be collected for all your jobs and combined together in a job at the end of the workflow. +If uploading to codecov they will be combined and uploaded at the end of each job. + +Both of these report uploads require the ``.coverage`` file(s) to be in the root of the GitHub Actions workspace for processing at the end of the job. +**If you are running your tests in a temporary directory**, the easiest way to achieve this is to set the following option in your tox.ini:: + + setenv = + COVERAGE_FILE={toxinidir}/.coverage + +This should work for both ``coverage.py`` and ``pytest-cov``. conda ^^^^^ @@ -612,6 +636,8 @@ like ``py311-test-cov`` and ``py312-test-cov`` instead of just ``py311`` and Secrets ~~~~~~~ +.. _codecov-token: + CODECOV_TOKEN ^^^^^^^^^^^^^ From 4265acef31fcd15690594a229fd15d3221796c90 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 12:01:37 +0100 Subject: [PATCH 05/16] Set COVERAGE_FILE in tox.ini --- tox.ini | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tox.ini b/tox.ini index 952ddb1c..d80edb6c 100644 --- a/tox.ini +++ b/tox.ini @@ -68,6 +68,8 @@ dependency_groups = conda_deps = pytest changedir = tmpdir: .tmp/{envname} +setenv = + tmpdir: COVERAGE_FILE={toxinidir}/.coverage commands = conda: python -c "import os, sys; assert os.path.exists(os.path.join(sys.prefix, 'conda-meta', 'history'))" conda: micromamba list From 3db5cbc64ef28a4b3f6cba34f793a068ea014b94 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 12:13:08 +0100 Subject: [PATCH 06/16] Add some codecov tests --- .github/workflows/test_tox.yml | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/.github/workflows/test_tox.yml b/.github/workflows/test_tox.yml index 7585ceed..9aca569e 100644 --- a/.github/workflows/test_tox.yml +++ b/.github/workflows/test_tox.yml @@ -171,6 +171,22 @@ jobs: - linux: py314-tmpdir posargs: --cov=test_package + test_coverage_codecov: + uses: ./.github/workflows/tox.yml + permissions: + id-token: write + with: + coverage: codecov + envs: | + # covcheck uses an explicit coverage run + - linux: py313-covcheck + # Now also test it works with pytest-cov + - linux: py314 + posargs: --cov=test_package + # And test it works if the pytest command isn't run in the toxinidir + - linux: py314-tmpdir + posargs: --cov=test_package + test_artifact_upload: uses: ./.github/workflows/tox.yml with: From 55d5f2fa57c86250ae7343f64fedc5ae9c6be427 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 12:25:13 +0100 Subject: [PATCH 07/16] Fail CI if codecov upload fails --- .github/workflows/tox.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 85f671a5..de735158 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -306,6 +306,7 @@ jobs: uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # v6.0.1 with: token: ${{ secrets.CODECOV_TOKEN }} # zizmor: ignore[secrets-outside-env] + fail_ci_if_error: true - name: Upload coverage data to GitHub id: upload-coverage-gh From 881bb20c38d25292c9a6fd2ef3fa01e15fb93a11 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 12:25:27 +0100 Subject: [PATCH 08/16] Explicitly generate an xml report for codecov --- .github/workflows/tox.yml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index de735158..04ef2079 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -300,6 +300,13 @@ jobs: with: paths: "**/results.xml" + - name: Generate xml report for Codecov + # Even if tox fails, upload coverage + if: ${{ (success() || failure()) && contains(matrix.coverage, 'codecov') && matrix.pytest == 'true' }} + run: | + uvx coverage combine + uvx coverage xml -i + - name: Upload to Codecov # Even if tox fails, upload coverage if: ${{ (success() || failure()) && contains(matrix.coverage, 'codecov') && matrix.pytest == 'true' }} From 6e95ce5d48f69e6f37b57d9945e040d57d307f30 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 12:25:43 +0100 Subject: [PATCH 09/16] Support oidc auth for codecov --- .github/workflows/test_tox.yml | 2 +- .github/workflows/tox.yml | 1 + docs/source/tox.rst | 28 +++++++++++++--------------- 3 files changed, 15 insertions(+), 16 deletions(-) diff --git a/.github/workflows/test_tox.yml b/.github/workflows/test_tox.yml index 9aca569e..ad0b7d23 100644 --- a/.github/workflows/test_tox.yml +++ b/.github/workflows/test_tox.yml @@ -176,7 +176,7 @@ jobs: permissions: id-token: write with: - coverage: codecov + coverage: codecov-oidc envs: | # covcheck uses an explicit coverage run - linux: py313-covcheck diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 04ef2079..bc052eea 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -313,6 +313,7 @@ jobs: uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # v6.0.1 with: token: ${{ secrets.CODECOV_TOKEN }} # zizmor: ignore[secrets-outside-env] + use_oidc: ${{ contains(matrix.coverage, 'codecov-oidc') }} fail_ci_if_error: true - name: Upload coverage data to GitHub diff --git a/docs/source/tox.rst b/docs/source/tox.rst index 5d06da2c..75a7503b 100644 --- a/docs/source/tox.rst +++ b/docs/source/tox.rst @@ -164,10 +164,9 @@ coverage ^^^^^^^^ The coverage option controls how coverage reports are made and processed after the tox job has completed. +The default is to not upload coverage reports. This option has no effect if ``pytest`` is ``false``. -This option takes a space separated list of coverage providers to upload to, either ``codecov`` or ``github``. -Default is to not upload coverage reports. -If using ``codecov`` see :ref:`codecov-token`. +This option takes a space separated list of coverage providers to upload to, either ``codecov``, ``codecov-oidc`` or ``github``. As the workflows do not control how your tests are run, configuring coverage correctly may require changes to your tox.ini. The coverage collection is done inside the tox job, but the workflows handle generating reports and uploading to either codecov or github. @@ -195,6 +194,17 @@ Both of these report uploads require the ``.coverage`` file(s) to be in the root This should work for both ``coverage.py`` and ``pytest-cov``. +.. _codecov-auth: + +Authenticating with Codecov +########################### + +There are two supported ways to authenticate with Codecov, either using a ``CODECOV_TOKEN`` or using `OIDC `__. + +To use the token set the ``CODECOV_TOKEN`` environment variable or pass it as a secret to the workflow, and set ``coverage: codecov``. +To use oidc you need to give the job the ``id-token: write`` permission, we recommend you set this on the job level not the workflow level, and set ``coverage: codecov-oidc``. + + conda ^^^^^ @@ -632,15 +642,3 @@ This is a comma-separated list of factors. Default is none. If your package supports Python 3.11 and 3.12, this will generate environments like ``py311-test-cov`` and ``py312-test-cov`` instead of just ``py311`` and ``py312``. - -Secrets -~~~~~~~ - -.. _codecov-token: - -CODECOV_TOKEN -^^^^^^^^^^^^^ - -If your repository is private, in order to upload to Codecov you need to -set the ``CODECOV_TOKEN`` environment variable or pass it as a secret to -the workflow. From 33e0dade96abac32315cd05c4599820c966d21de Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 12:47:20 +0100 Subject: [PATCH 10/16] BREAKING CHANGE: Remove --cov-report pytest flag --- .github/workflows/tox.yml | 2 +- tools/tox_matrix.py | 8 -------- 2 files changed, 1 insertion(+), 9 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index bc052eea..5ea38684 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -173,7 +173,7 @@ jobs: shell: sh - 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 warnings

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("--artifact-archive", default="true")
@click.option("--artifact-include-hidden-files", default="false")
@click.option("--artifact-if-no-files-found", default="warn")
@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,
    artifact_archive,
    artifact_include_hidden_files,
    artifact_if_no_files_found,
    runs_on,
    default_python,
    timeout_minutes,
):
    """Script to load tox targets for GitHub Actions workflow."""
    # Load envs config
    envs = yaml.load(envs.replace("\\n", "\n"), 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,
        "artifact-archive": artifact_archive,
        "artifact-include-hidden-files": artifact_include_hidden_files,
        "artifact-if-no-files-found": artifact_if_no_files_found,
        "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,
        "artifact-archive": None,
        "artifact-include-hidden-files": None,
        "artifact-if-no-files-found": 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", ""):
            # Note that we don't include --cov here as if it's provided to pytest twice it breaks cov reporting.
            # Lots of users of this specify --cov in their tox.ini so it's been removed for backwards compatibility.
            # https://github.com/OpenAstronomy/github-actions-workflows/issues/383
            item["pytest_flag"] += (
                rf"--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, []))

    if item["conda"]:
        warnings.warn("`conda` parameter is deprecated")

        # 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 warnings

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("--artifact-archive", default="true")
@click.option("--artifact-include-hidden-files", default="false")
@click.option("--artifact-if-no-files-found", default="warn")
@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,
    artifact_archive,
    artifact_include_hidden_files,
    artifact_if_no_files_found,
    runs_on,
    default_python,
    timeout_minutes,
):
    """Script to load tox targets for GitHub Actions workflow."""
    # Load envs config
    envs = yaml.load(envs.replace("\\n", "\n"), 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,
        "artifact-archive": artifact_archive,
        "artifact-include-hidden-files": artifact_include_hidden_files,
        "artifact-if-no-files-found": artifact_if_no_files_found,
        "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,
        "artifact-archive": None,
        "artifact-include-hidden-files": None,
        "artifact-if-no-files-found": 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 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, []))

    if item["conda"]:
        warnings.warn("`conda` parameter is deprecated")

        # 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: | # zizmor: ignore[template-injection] diff --git a/tools/tox_matrix.py b/tools/tox_matrix.py index 9ceed1ad..a1153cf0 100644 --- a/tools/tox_matrix.py +++ b/tools/tox_matrix.py @@ -184,14 +184,6 @@ def get_matrix_item(env, global_libraries, global_string_parameters, runs_on, de item["pytest_flag"] = "" sep = r"\\" if platform == "windows" else "/" if item["pytest"] == "true": - if "codecov" in item.get("coverage", ""): - # Note that we don't include --cov here as if it's provided to pytest twice it breaks cov reporting. - # Lots of users of this specify --cov in their tox.ini so it's been removed for backwards compatibility. - # https://github.com/OpenAstronomy/github-actions-workflows/issues/383 - item["pytest_flag"] += ( - rf"--cov-report=xml:${{GITHUB_WORKSPACE}}{sep}coverage.xml " - ) - if item["pytest-results-summary"] == "true": item["pytest_flag"] += rf"--junitxml ${{GITHUB_WORKSPACE}}{sep}results.xml " From 63806a19fba1d8a0903f60b507b4664bef2630b4 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 12:56:01 +0100 Subject: [PATCH 11/16] Try to reproduce sunpy fail --- .github/workflows/test_tox.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/test_tox.yml b/.github/workflows/test_tox.yml index ad0b7d23..c718ef25 100644 --- a/.github/workflows/test_tox.yml +++ b/.github/workflows/test_tox.yml @@ -167,6 +167,12 @@ jobs: # Now also test it works with pytest-cov - linux: py314 posargs: --cov=test_package + + test_coverage_github_tmpdir: + uses: ./.github/workflows/tox.yml + with: + coverage: github + envs: | # And test it works if the pytest command isn't run in the toxinidir - linux: py314-tmpdir posargs: --cov=test_package From 5dfa618e02a72539c9c20084c00388883b9ced8b Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 13:14:24 +0100 Subject: [PATCH 12/16] Add docs on source mapping for coverage: github --- docs/source/tox.rst | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/docs/source/tox.rst b/docs/source/tox.rst index 75a7503b..0d0692ca 100644 --- a/docs/source/tox.rst +++ b/docs/source/tox.rst @@ -187,13 +187,26 @@ If uploading to GitHub all these reports will be collected for all your jobs and If uploading to codecov they will be combined and uploaded at the end of each job. Both of these report uploads require the ``.coverage`` file(s) to be in the root of the GitHub Actions workspace for processing at the end of the job. -**If you are running your tests in a temporary directory**, the easiest way to achieve this is to set the following option in your tox.ini:: + +**If you are running your tests in a temporary directory**, more configuration may be required to configure the coverage collection correctly. + +The first step is to write the ``.coverage`` file to the same dir as the ``tox.ini`` to do this set the following option in your tox.ini:: setenv = COVERAGE_FILE={toxinidir}/.coverage This should work for both ``coverage.py`` and ``pytest-cov``. +The next thing you may need to configure is `source mapping `__ to map the source code in the temporary directory to the source code in the repository checkout. +This is normally only needed when using ``coverage: github`` as the report is generated in a separate Github Actions job meaning the temporary directory is no longer present. + +An example of this is in the ``.coveragerc`` file:: + + [paths] + source = + test_package/ + .tox/**/test_package + .. _codecov-auth: Authenticating with Codecov From fc76dfac659d466e89713b63e511425673f4dc85 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 13:20:00 +0100 Subject: [PATCH 13/16] Ignore errors in coverage combine No combining may be needed --- .github/workflows/tox.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index 5ea38684..e09cbe56 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -304,7 +304,8 @@ jobs: # Even if tox fails, upload coverage if: ${{ (success() || failure()) && contains(matrix.coverage, 'codecov') && matrix.pytest == 'true' }} run: | - uvx coverage combine + # combine will exit 1 if it's a no-op which is ok for us + uvx coverage combine; uvx coverage xml -i - name: Upload to Codecov @@ -353,7 +354,8 @@ jobs: ignore-empty-workdir: "true" - name: generate coverage report run: | - uvx coverage combine + # combine will exit 1 if it's a no-op which is ok for us + uvx coverage combine; uvx coverage report -i -m --format=markdown >> $GITHUB_STEP_SUMMARY - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: From 9d321c76a49d39b2ac18dfcdfe5da4950a863626 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 13:28:03 +0100 Subject: [PATCH 14/16] Split combine and report --- .github/workflows/tox.yml | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index e09cbe56..bb88717b 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -343,20 +343,24 @@ jobs: submodules: ${{ inputs.submodules }} ref: ${{ inputs.checkout_ref }} persist-credentials: false - - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + - name: download coverage reports uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: pattern: coverage-data-${{ github.run_id }}-* merge-multiple: true + - uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # 8.1.0 with: ignore-empty-workdir: "true" - - name: generate coverage report - run: | - # combine will exit 1 if it's a no-op which is ok for us - uvx coverage combine; - uvx coverage report -i -m --format=markdown >> $GITHUB_STEP_SUMMARY + + - name: Combine Coverage + continue-on-error: true + run: uvx coverage combine + + - name: Combine Coverage + run: uvx coverage report -i -m --format=markdown >> $GITHUB_STEP_SUMMARY + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: coverage-report-${{ hashFiles('.coverage') }} From e0c57e958c5567d0120d49e55cd8ee8165b5c690 Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 17:45:42 +0100 Subject: [PATCH 15/16] Some more tweaks --- .github/workflows/test_tox.yml | 9 +++------ .github/workflows/tox.yml | 14 ++++++++++++-- tox.ini | 4 ++-- 3 files changed, 17 insertions(+), 10 deletions(-) diff --git a/.github/workflows/test_tox.yml b/.github/workflows/test_tox.yml index c718ef25..66dc7f7b 100644 --- a/.github/workflows/test_tox.yml +++ b/.github/workflows/test_tox.yml @@ -167,12 +167,6 @@ jobs: # Now also test it works with pytest-cov - linux: py314 posargs: --cov=test_package - - test_coverage_github_tmpdir: - uses: ./.github/workflows/tox.yml - with: - coverage: github - envs: | # And test it works if the pytest command isn't run in the toxinidir - linux: py314-tmpdir posargs: --cov=test_package @@ -192,6 +186,9 @@ jobs: # And test it works if the pytest command isn't run in the toxinidir - linux: py314-tmpdir posargs: --cov=test_package + # This job should fail and print a warning + - linux: py314-tmpdir_warning + posargs: --cov=test_package test_artifact_upload: uses: ./.github/workflows/tox.yml diff --git a/.github/workflows/tox.yml b/.github/workflows/tox.yml index bb88717b..0aa7c38d 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -300,12 +300,22 @@ jobs: with: paths: "**/results.xml" + - name: Combine converage reports for Codecov + # Even if tox fails, upload coverage + if: ${{ (success() || failure()) && contains(matrix.coverage, 'codecov') && matrix.pytest == 'true' }} + # If there's not multiple files to combine then this will error but that's ok + continue-on-error: true + run: | + uvx coverage combine + - name: Generate xml report for Codecov # Even if tox fails, upload coverage if: ${{ (success() || failure()) && contains(matrix.coverage, 'codecov') && matrix.pytest == 'true' }} run: | - # combine will exit 1 if it's a no-op which is ok for us - uvx coverage combine; + if [ ! -f ".coverage" ]; then + echo "> [!WARNING]" >> $GITHUB_STEP_SUMMARY + echo "> No `.coverage` file was found in the root directory, this is now a requirement for uploading coverage to Codecov. See the documentation for more information: https://github-actions-workflows.openastronomy.org/en/stable/tox.html#coverage" >> $GITHUB_STEP_SUMMARY + fi uvx coverage xml -i - name: Upload to Codecov diff --git a/tox.ini b/tox.ini index d80edb6c..c4d2ae92 100644 --- a/tox.ini +++ b/tox.ini @@ -59,7 +59,7 @@ description = verify pep8 deps = ruff commands = ruff check . -[testenv:py3{10-16}{,-conda,-tmpdir}] +[testenv:py3{10-16}{,-conda,-tmpdir,-tmpdir_warning}] description = run pytest skip_install = false dependency_groups = @@ -67,7 +67,7 @@ dependency_groups = covcheck conda_deps = pytest changedir = - tmpdir: .tmp/{envname} + tmpdir,tmpdir_warning: .tmp/{envname} setenv = tmpdir: COVERAGE_FILE={toxinidir}/.coverage commands = From a1cc672d83450fa190fdcb4650e46728d98d176e Mon Sep 17 00:00:00 2001 From: Stuart Mumford Date: Wed, 3 Jun 2026 17:12:21 +0000 Subject: [PATCH 16/16] Update docs/source/tox.rst Co-authored-by: P. L. Lim <2090236+pllim@users.noreply.github.com> --- docs/source/tox.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/tox.rst b/docs/source/tox.rst index 0d0692ca..56c53489 100644 --- a/docs/source/tox.rst +++ b/docs/source/tox.rst @@ -166,7 +166,7 @@ coverage The coverage option controls how coverage reports are made and processed after the tox job has completed. The default is to not upload coverage reports. This option has no effect if ``pytest`` is ``false``. -This option takes a space separated list of coverage providers to upload to, either ``codecov``, ``codecov-oidc`` or ``github``. +This option takes a space separated list of coverage providers to upload to, either ``codecov``, ``codecov-oidc``, or ``github``. As the workflows do not control how your tests are run, configuring coverage correctly may require changes to your tox.ini. The coverage collection is done inside the tox job, but the workflows handle generating reports and uploading to either codecov or github.