ci.yaml

name: CI

# Controls when the action will run.
on:
    # Triggers the workflow on push or pull request events but only for the main branch
    push:
        branches: [main]
    pull_request:
        branches: [main]

    # Allows you to run this workflow manually from the Actions tab
    workflow_dispatch:

jobs:
    # matrix-prep-* steps dynamically generate a bit of JSON depending on whether our action has
    # access to repository secrets. When running on a pull_request from a fork, the author is
    # untrusted so the secret will be absent. Insanely complex for how simple this requirement is...
    # inspired from
    # https://stackoverflow.com/questions/65384420/how-to-make-a-github-action-matrix-element-conditional

    matrix-prep-bazelversion:
        # Prepares the 'bazelversion' axis of the test matrix
        runs-on: ubuntu-latest
        steps:
            - uses: actions/checkout@v3
            - id: bazel_6
              run: echo "bazelversion=$(head -n 1 .bazelversion)" >> $GITHUB_OUTPUT
            - id: bazel_5
              run: echo "bazelversion=5.3.2" >> $GITHUB_OUTPUT
        outputs:
            # Will look like ["<version from .bazelversion>", "5.3.2"]
            bazelversions: ${{ toJSON(steps.*.outputs.bazelversion) }}

    matrix-prep-os:
        # Prepares the 'os' axis of the test matrix
        runs-on: ubuntu-latest
        steps:
            - uses: actions/checkout@v3
            - id: linux
              run: echo "os=ubuntu-latest" >> $GITHUB_OUTPUT
            - id: macos
              run: echo "os=macos-latest" >> $GITHUB_OUTPUT
              # Only run on main branch (not PRs) to minimize macOS minutes (billed at 10X)
              # https://docs.github.com/en/billing/managing-billing-for-github-actions/about-billing-for-github-actions#included-storage-and-minutes
              if: ${{ github.ref == 'refs/heads/main' }}
        outputs:
            # Will look like ["ubuntu-latest", "macos-latest"]
            os: ${{ toJSON(steps.*.outputs.os) }}

    test:
        # The type of runner that the job will run on
        runs-on: ${{ matrix.os }}

        needs:
            - matrix-prep-bazelversion
            - matrix-prep-os

        strategy:
            fail-fast: false
            matrix:
                os: ${{ fromJSON(needs.matrix-prep-os.outputs.os) }}
                bazelversion: ${{ fromJSON(needs.matrix-prep-bazelversion.outputs.bazelversions) }}
                bzlmodEnabled: [true, false]
                folder:
                    - '.'
                    - 'e2e/smoke'
                exclude:
                    # Don't test macos with Bazel 5 to minimize macOS minutes (billed at 10X)
                    # https://docs.github.com/en/billing/managing-billing-for-github-actions/about-billing-for-github-actions#included-storage-and-minutes
                    - os: macos-latest
                      bazelversion: 5.3.2
                    # Don't test bzlmod with Bazel 5 (not supported)
                    - bazelversion: 5.3.2
                      bzlmodEnabled: true

        # Steps represent a sequence of tasks that will be executed as part of the job
        steps:
            # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
            - uses: actions/checkout@v3

            # Cache build and external artifacts so that the next ci build is incremental.
            # Because github action caches cannot be updated after a build, we need to
            # store the contents of each build in a unique cache key, then fall back to loading
            # it on the next ci run. We use hashFiles(...) in the key and restore-keys- with
            # the prefix to load the most recent cache for the branch on a cache miss. You
            # should customize the contents of hashFiles to capture any bazel input sources,
            # although this doesn't need to be perfect. If none of the input sources change
            # then a cache hit will load an existing cache and bazel won't have to do any work.
            # In the case of a cache miss, you want the fallback cache to contain most of the
            # previously built artifacts to minimize build time. The more precise you are with
            # hashFiles sources the less work bazel will have to do.
            - name: Mount bazel caches
              uses: actions/cache@v3
              with:
                  path: |
                      "~/.cache/bazel"
                      "~/.cache/bazel-repo"
                  key: bazel-cache-${{ hashFiles('**/BUILD.bazel', '**/*.bzl', 'WORKSPACE') }}
                  restore-keys: bazel-cache-

            - name: Configure Bazel version
              working-directory: ${{ matrix.folder }}
              # Overwrite the .bazelversion instead of using USE_BAZEL_VERSION so that Bazelisk
              # still bootstraps Aspect CLI from configuration in .bazeliskrc. Aspect CLI will
              # then use .bazelversion to determine which Bazel version to use
              run: echo "${{ matrix.bazelversion }}" > .bazelversion

            - name: Set bzlmod flag
              # Store the --enable_bzlmod flag that we add to the test command below
              # only when we're running bzlmod in our test matrix.
              id: set_bzlmod_flag
              if: matrix.bzlmodEnabled
              run: echo "bzlmod_flag=--enable_bzlmod" >> $GITHUB_OUTPUT

            - name: bazel test //...
              env:
                  # Bazelisk will download bazel to here, ensure it is cached between runs.
                  XDG_CACHE_HOME: ~/.cache/bazel-repo
              working-directory: ${{ matrix.folder }}
              run: bazel --bazelrc=$GITHUB_WORKSPACE/.github/workflows/ci.bazelrc --bazelrc=.bazelrc test ${{ steps.set_bzlmod_flag.outputs.bzlmod_flag }} //...