test.yml

# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

name: Test

on:
  workflow_call:
    inputs:
      platform:
        required: true
        type: string
      config:
        required: true
        type: string
      suite:
        required: true
        type: string
      bucket:
        required: false
        type: string
        default: ""
      coverage:
        required: false
        type: boolean
        default: false

jobs:
  test:
    name: "Test (${{ inputs.suite }}${{ inputs.bucket != '' && format(':{0}', inputs.bucket) || '' }})"
    runs-on: [self-hosted, gpu]
    timeout-minutes: 120
    defaults:
      run:
        shell: bash
    env:
      OMNI_KIT_ALLOW_ROOT: 1
      NVIDIA_VISIBLE_DEVICES: all
      NVIDIA_DRIVER_CAPABILITIES: all
      CUDA_HOME: /usr/local/cuda
      LD_LIBRARY_PATH: /usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64
      DISPLAY: ':0'
      GITLAB_CI: gitlab

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
          lfs: true

      - name: Make repo scripts executable
        run: |
          chmod -R u+w .
          find . -type f -iname "*.sh" -exec chmod +x {} +

      - name: Download packaged artifacts
        uses: actions/download-artifact@v4
        with:
          name: isaac-sim-packages-${{ inputs.platform }}-${{ inputs.config }}${{ inputs.coverage && '-cov' || '' }}
          path: _build/packages/

      - name: Verify downloaded artifacts against build manifest
        run: |
          set -euo pipefail
          echo "=== Verifying artifact integrity ==="
          manifest="_build/packages/artifact-manifest.txt"
          if [ ! -f "$manifest" ]; then
            echo "::error::No artifact-manifest.txt found — build may not include manifest yet"
            echo "Falling back to basic existence check"
            mapfile -t archives < <(find _build/packages/ -name '*.7z' -o -name '*.zip')
            if [ ${#archives[@]} -eq 0 ]; then
              echo "::error::No archives found in _build/packages/"
              exit 1
            fi
            for archive in "${archives[@]}"; do
              echo "  $(basename "$archive")  size=$(stat -c%s "$archive")  sha256=$(sha256sum "$archive" | cut -d' ' -f1)"
            done
            exit 0
          fi
          echo "Manifest contents:"
          cat "$manifest"
          echo "---"
          errors=0
          while IFS= read -r line; do
            [ -z "$line" ] && continue
            expected_sha=$(echo "$line" | awk '{print $1}')
            expected_size=$(echo "$line" | awk '{print $2}')
            filename=$(echo "$line" | awk '{print $3}')
            # Find the file on disk
            actual_file=$(find _build/packages/ -name "$filename" -print -quit)
            if [ -z "$actual_file" ]; then
              echo "::error::Manifest lists $filename but file not found on disk"
              errors=$((errors + 1))
              continue
            fi
            actual_size=$(stat -c%s "$actual_file")
            actual_sha=$(sha256sum "$actual_file" | cut -d' ' -f1)
            if [ "$actual_size" != "$expected_size" ] || [ "$actual_sha" != "$expected_sha" ]; then
              echo "::error::MISMATCH: $filename"
              echo "  expected: size=$expected_size  sha256=$expected_sha"
              echo "  actual:   size=$actual_size  sha256=$actual_sha"
              if [ "$actual_size" != "$expected_size" ]; then
                diff_bytes=$((expected_size - actual_size))
                echo "  size difference: $diff_bytes bytes"
              fi
              errors=$((errors + 1))
            else
              echo "  OK: $filename  size=$actual_size  sha256=$actual_sha"
            fi
          done < "$manifest"
          if [ "$errors" -gt 0 ]; then
            echo "::error::$errors artifact(s) failed integrity check — download was corrupted"
            echo "=== Disk usage (df -h) ==="
            df -h
            echo "=== _build/packages/ listing ==="
            ls -lah _build/packages/
            exit 1
          fi
          echo "All artifacts verified against build manifest ✓"

      - name: Run tests
        env:
          TEST_BUCKET: ${{ inputs.bucket }}
          TEST_CONFIG: ${{ inputs.config }}
          TEST_SUITE: ${{ inputs.suite }}
        run: |
          set -euo pipefail
          set -x

          touch .eula_accepted

          BUCKET_ARGS=()
          if [ -n "${TEST_BUCKET}" ]; then
            BUCKET_ARGS=(-b "${TEST_BUCKET}")
          fi

          echo "::group::Test ${TEST_SUITE} ${TEST_BUCKET}"
          ./repo.sh test -c "${TEST_CONFIG}" -s "${TEST_SUITE}" "${BUCKET_ARGS[@]}" --from-package \
            --extra-arg="--/rtx-transient/ngx/enabled=false"
          echo "::endgroup::"

      - name: Upload test results
        uses: actions/upload-artifact@v4
        with:
          name: test-results-${{ inputs.suite }}-${{ inputs.bucket || 'all' }}
          path: |
            _build/packages/*/_testoutput/**
            _build/packages/*/kit/logs/**
            _build/packages/*/portable_root/logs/**
          retention-days: 7
        if: always()

      - name: Collect coverage data
        if: always() && inputs.coverage
        run: |
          set -x
          echo "=== Collecting coverage artifacts ==="

          mkdir -p _coverage_output

          # Collect C++ coverage data (.gcda files produced during test execution)
          find . -name "*.gcda" -not -path "./.git/*" -exec cp --parents {} _coverage_output/ \; 2>/dev/null || true
          GCDA_COUNT=$(find _coverage_output -name "*.gcda" 2>/dev/null | wc -l)
          echo "Found $GCDA_COUNT .gcda files"
          du -sh _coverage_output/ 2>/dev/null || true

      - name: Upload coverage artifacts
        if: always() && inputs.coverage
        uses: actions/upload-artifact@v4
        with:
          name: coverage-${{ inputs.suite }}-${{ inputs.bucket || 'all' }}
          path: _coverage_output/
          retention-days: 7
          if-no-files-found: warn