action.yml

name: "Test Rust Library and Upload Coverage"
description: "Runs tests for a Rust library using Tarpaulin and uploads the coverage to Codecov."
branding:
  icon: "check"
  color: "green"

inputs:
  rust-project-path:
    description: "Directory containing Cargo.toml (crate root or workspace root)"
    required: false
    default: "."
  rust-toolchain:
    description: "Rust toolchain to use for building and testing (e.g., stable, nightly, 1.75.0, nightly-2024-02-08)"
    required: false
    default: "stable"
  target:
    description: "The target platform for the Rust compiler"
    required: false
    default: ""
  install-rust-toolchain:
    description: "Whether to install the specified Rust toolchain"
    required: false
    default: "true"
  setup-rust-cache:
    description: "Whether to set up Rust caching"
    required: false
    default: "true"
  cache-workspace-crates:
    description: "Whether rust-cache should cache workspace crates"
    required: false
    default: "true"
  cache-directories:
    description: >-
      Additional directories to cache, relative to rust-project-path unless
      absolute. The rustdoc directory is cached automatically.
    required: false
    default: ""
  use-tarpaulin:
    description: "Whether to use Tarpaulin for code coverage. If false, only runs tests."
    required: false
    default: "true"
  use-binstall:
    description: "Whether to use cargo-binstall for installing components like tarpaulin. If false, uses cargo install."
    required: false
    default: "true"
  install-binstall:
    description: "Whether to install cargo-binstall. If false, assumes it is already available in the environment."
    required: false
    default: "true"
  upload-coverage:
    description: "Whether to upload coverage to Codecov"
    required: false
    default: "true"
  codecov-token:
    description: "Codecov token for uploading coverage"
    required: false
  codecov-flags:
    description: "Flags to pass to Codecov"
    required: false
    default: "unittests"
  codecov-name:
    description: "Custom defined name for the upload"
    required: false
    default: "codecov-umbrella"
  features:
    description: "Space-separated list of features to enable during testing"
    required: false
    default: ""
  no-default-features:
    description: "Disable default features during testing"
    required: false
    default: "false"
  use-cross:
    description: "Use cross-rs for testing. If false, use cargo."
    required: false
    default: "false"
  additional-test-args:
    description: "Additional arguments to pass to the cargo test command"
    required: false
    default: ""
  additional-tarpaulin-args:
    description: "Additional arguments to pass to the cargo tarpaulin command"
    required: false
    default: ""
  pre-test-command:
    description: "Bash command to run before executing tests"
    required: false
    default: ""

  packages:
    description: "Multi-line list of package names to test (one per line). If empty, tests all packages in workspace (--all)"
    required: false
    default: ""

runs:
  using: "composite"
  steps:
    - name: Extract features and additional test args for cache in friendly to cache-key manner
      shell: bash
      run: |
        echo "SAFE_FEATURES=$(echo ${{ inputs.features }} | tr ',' '-' | tr -d ' ')" >> $GITHUB_ENV
        SAFE_ADDITIONAL_TEST_ARGS=$(echo "${{ inputs.additional-test-args }}" | tr -dc '[:alnum:],_-' | tr ',' '-')
        if [ -z "$SAFE_ADDITIONAL_TEST_ARGS" ]; then
          SAFE_ADDITIONAL_TEST_ARGS="no-test-args"
        fi
        echo "SAFE_ADDITIONAL_TEST_ARGS=${SAFE_ADDITIONAL_TEST_ARGS}" >> $GITHUB_ENV

        # Process packages input - convert multiline to space-separated, clean whitespace
        SAFE_PACKAGES=$(echo "${{ inputs.packages }}" | tr -d '\r' | tr '\n\t' '  ' | tr -s ' ' | sed 's/^ *//;s/ *$//')
        echo "SAFE_PACKAGES=${SAFE_PACKAGES}" >> $GITHUB_ENV

        if [ -z "$SAFE_PACKAGES" ]; then
          SAFE_PACKAGES_KEY="all-packages"
        else
          # rust-cache rejects commas in cache keys, so use a cache-safe separator.
          SAFE_PACKAGES_KEY=$(echo "$SAFE_PACKAGES" | tr ' ' '+')
        fi
        echo "SAFE_PACKAGES_KEY=${SAFE_PACKAGES_KEY}" >> $GITHUB_ENV

        # Build packages argument once and reuse across steps
        if [ -n "$SAFE_PACKAGES" ]; then
          PACKAGES_ARG=""
          for pkg in $SAFE_PACKAGES; do
            if [ -n "$pkg" ]; then
              if [ -z "$PACKAGES_ARG" ]; then
                PACKAGES_ARG="-p $pkg"
              else
                PACKAGES_ARG="$PACKAGES_ARG -p $pkg"
              fi
            fi
          done
        else
          PACKAGES_ARG="--all"
        fi
        echo "PACKAGES_ARG=${PACKAGES_ARG}" >> $GITHUB_ENV

    # rust-cache prunes rustdoc output by default, so resolve the automatic
    # rustdoc path plus any caller-provided cache directories here.
    - name: Normalize rust-cache directories
      if: inputs.setup-rust-cache == 'true'
      shell: bash
      run: python3 "${{ github.action_path }}/scripts/resolve_cache_directories.py"
      env:
        INPUT_RUST_PROJECT_PATH: ${{ inputs.rust-project-path }}
        INPUT_TARGET: ${{ inputs.target }}
        INPUT_CACHE_DIRECTORIES: ${{ inputs.cache-directories }}

    - name: Install Rust Toolchain
      if: inputs.install-rust-toolchain == 'true'
      uses: actions-rust-lang/setup-rust-toolchain@v1
      with:
        toolchain: ${{ inputs.rust-toolchain }}
        target: ${{ inputs.target }}
        cache: false
        components: "clippy,rustfmt"

    # Needs to be done after installing toolchain, don't move!
    - name: Setup Rust Caching
      if: inputs.setup-rust-cache == 'true'
      uses: Swatinem/rust-cache@v2
      with:
        key:
          test-${{ inputs.rust-toolchain }}-${{ inputs.rust-project-path }}-${{ inputs.target }}-${{ env.SAFE_FEATURES
          }}-${{ inputs.no-default-features }}-${{ inputs.use-cross }}-${{ env.SAFE_PACKAGES_KEY
          }}-${{ env.SAFE_ADDITIONAL_TEST_ARGS }}-${{ inputs.cache-workspace-crates }}
        cache-on-failure: true
        cache-all-crates: true
        cache-workspace-crates: ${{ inputs.cache-workspace-crates }}
        cache-bin: ${{ inputs.use-binstall == 'true' && 'false' || 'true' }} # Disable binary caching when using binstall to avoid conflicts
        workspaces: |
          ${{ inputs.rust-project-path }} -> target
        cache-directories: ${{ env.RUST_CACHE_DIRECTORIES }}

    - name: Install gcc-multilib (if on Ubuntu based System, and Target is not Host)
      if: inputs.use-cross == 'false' && runner.os == 'Linux'
      shell: bash
      run: |
        # Get host triple
        HOST_TARGET=$(rustc -vV | sed -n 's|host: ||p')
        echo "Host target: $HOST_TARGET"
        echo "Target: ${{ inputs.target }}"

        if [ "$HOST_TARGET" != "${{ inputs.target }}" ]; then
          echo "Target is different from host. Installing gcc-multilib and g++-multilib..."
          sudo apt-get update || true
          sudo apt-get install -y gcc-multilib g++-multilib || true
        else
          echo "Target is the same as host. Skipping gcc-multilib installation."
        fi

    - name: Install cross
      if: inputs.use-cross == 'true'
      shell: bash
      run: RUSTFLAGS="" cargo install cross --git https://github.com/cross-rs/cross

    - name: Install cargo-binstall
      if: inputs.install-binstall == 'true'
      uses: cargo-bins/cargo-binstall@main
      env:
        GITHUB_TOKEN: ${{ github.token }}

    - name: Install Tarpaulin (via binstall)
      if: inputs.use-cross == 'false' && inputs.use-tarpaulin == 'true' && inputs.use-binstall == 'true'
      shell: bash
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
        # The force here is kinda forced for back compat reasons, else cargo might not pick up the binary;
        # while binstall thinks it's there due to caching. Current versions wouldn't cache preinstalled cargo-tarpaulin
        # but they may reside from older CI runs in other repos.
        cargo +${{ inputs.rust-toolchain }} binstall cargo-tarpaulin --force

    - name: Install Tarpaulin (via cargo install)
      if: inputs.use-cross == 'false' && inputs.use-tarpaulin == 'true' && inputs.use-binstall == 'false'
      shell: bash
      run: |
        cargo +${{ inputs.rust-toolchain }} install cargo-tarpaulin

    - name: Run Pre-Test Command
      if: inputs.pre-test-command != ''
      shell: bash
      run: ${{ inputs.pre-test-command }}

    - name: Run Tarpaulin
      if: inputs.use-cross == 'false' && inputs.use-tarpaulin == 'true'
      shell: bash
      working-directory: ${{ inputs.rust-project-path }}
      run: |
        cargo +${{ inputs.rust-toolchain }} tarpaulin $PACKAGES_ARG --out xml --engine llvm \
          --features "${{ inputs.features }}" \
          ${{ inputs.no-default-features == 'true' && '--no-default-features' || '' }} \
          ${{ inputs.target != '' && format('--target "{0}"', inputs.target) || '' }} \
          --skip-clean \
          ${{ inputs.additional-test-args }} \
          ${{ inputs.additional-tarpaulin-args }}

    - name: Run Tests with cargo
      if: inputs.use-cross == 'false' && inputs.use-tarpaulin == 'false'
      shell: bash
      working-directory: ${{ inputs.rust-project-path }}
      run: |
        cargo +${{ inputs.rust-toolchain }} test $PACKAGES_ARG \
          --features "${{ inputs.features }}" \
          ${{ inputs.no-default-features == 'true' && '--no-default-features' || '' }} \
          ${{ inputs.target != '' && format('--target "{0}"', inputs.target) || '' }} \
          ${{ inputs.additional-test-args }}

    - name: Run Tests with cross
      if: inputs.use-cross == 'true'
      shell: bash
      working-directory: ${{ inputs.rust-project-path }}
      # the RUSTFLAGS are a hack around cross build errors on certain setups
      # https://github.com/cross-rs/cross/issues/1561
      run: |
        RUSTFLAGS="" cross +${{ inputs.rust-toolchain }} test $PACKAGES_ARG \
          --features "${{ inputs.features }}" \
          ${{ inputs.no-default-features == 'true' && '--no-default-features' || '' }} \
          ${{ inputs.target != '' && format('--target "{0}"', inputs.target) || '' }} \
          ${{ inputs.additional-test-args }}

    - name: Upload Coverage to Codecov
      if: inputs.upload-coverage == 'true' && inputs.use-cross == 'false' && inputs.use-tarpaulin == 'true'
      uses: codecov/codecov-action@v6
      with:
        files: ${{ inputs.rust-project-path }}/cobertura.xml
        flags: ${{ inputs.codecov-flags }}
        name: ${{ inputs.codecov-name }}
        token: ${{ inputs.codecov-token }}
        fail_ci_if_error: true
        verbose: true