diff --git a/.github/workflows/test_tox.yml b/.github/workflows/test_tox.yml index 435ca28..a430d4a 100644 --- a/.github/workflows/test_tox.yml +++ b/.github/workflows/test_tox.yml @@ -164,8 +164,33 @@ 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 + # And test it works if the pytest command isn't run in the toxinidir + - linux: py314-tmpdir + posargs: --cov=test_package + + test_coverage_codecov: + uses: ./.github/workflows/tox.yml + permissions: + id-token: write + with: + coverage: codecov-oidc + 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 + # 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 035de51..c2b52ae 100644 --- a/.github/workflows/tox.yml +++ b/.github/workflows/tox.yml @@ -172,7 +172,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] @@ -209,8 +209,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 @@ -298,12 +298,32 @@ 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: | + 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 # Even if tox fails, upload coverage if: ${{ (success() || failure()) && contains(matrix.coverage, 'codecov') && matrix.pytest == 'true' }} 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 id: upload-coverage-gh @@ -311,7 +331,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: @@ -329,19 +351,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: | - 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') }} diff --git a/docs/source/tox.rst b/docs/source/tox.rst index 73e1340..56c5348 100644 --- a/docs/source/tox.rst +++ b/docs/source/tox.rst @@ -163,13 +163,60 @@ 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. +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``. -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. + +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**, 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 +########################### + +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``. -This option has no effect if ``pytest`` is ``false``. conda ^^^^^ @@ -608,13 +655,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 -^^^^^^^^^^^^^ - -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. diff --git a/tools/tox_matrix.py b/tools/tox_matrix.py index 9ceed1a..a1153cf 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 " diff --git a/tox.ini b/tox.ini index cfe6b40..c4d2ae9 100644 --- a/tox.ini +++ b/tox.ini @@ -59,11 +59,17 @@ description = verify pep8 deps = ruff commands = ruff check . -[testenv:py3{10,11,12}{,-conda}] +[testenv:py3{10-16}{,-conda,-tmpdir,-tmpdir_warning}] description = run pytest skip_install = false -dependency_groups = test +dependency_groups = + test + covcheck conda_deps = pytest +changedir = + tmpdir,tmpdir_warning: .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