qa-rpc-integration-tests-gnosis.yml

name: QA - RPC Integration Tests (Gnosis)

on:
  push:
    branches:
      - main
      - 'release/**'
  pull_request:
    branches:
      - main
      - 'release/**'
    types:
      - opened
      - reopened
      - synchronize
      - ready_for_review
  workflow_dispatch:     # Run manually

concurrency:
  group: >-
    ${{
      github.event_name == 'pull_request' &&
      format('{0}-{1}-{2}', github.workflow, github.event_name, github.head_ref) ||
      github.event_name == 'push' &&
      format('{0}-{1}-{2}', github.workflow, github.event_name, github.ref_name) ||
      format('{0}-{1}', github.workflow, github.run_id)
    }}
  cancel-in-progress: ${{ github.event_name == 'pull_request' }}

permissions:
  contents: read

jobs:
  gnosis-rpc-integ-tests:
    runs-on: [ self-hosted, qa, Gnosis, rpc-integration ]
    env:
      ERIGON_TESTBED_AREA: /opt/erigon-testbed
      ERIGON_QA_PATH: /home/qarunner/erigon-qa
      ERIGON_ASSERT: true
      RPC_PAST_TEST_DIR: /opt/rpc-past-tests
      CHAIN: gnosis

    steps:
      - name: Check out repository
        uses: actions/checkout@v7
        with:
          persist-credentials: false

      - name: Set up job-scoped build temp dir
        run: |
          # Confine build temp (Go work dirs + cgo/gcc cc* files) to one job-scoped dir
          # outside the checkout, so it can be removed wholesale when the job exits.
          BUILD_TMP="${RUNNER_TEMP}/erigon-build-tmp-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}"
          # Drop leftovers from a previously cancelled run (this runner builds serially).
          find "${RUNNER_TEMP}" -maxdepth 1 -name 'erigon-build-tmp-*' -exec rm -rf {} + 2>/dev/null || true
          mkdir -p "${BUILD_TMP}"
          {
            echo "BUILD_TMP=${BUILD_TMP}"
            echo "TMPDIR=${BUILD_TMP}"
            echo "GOTMPDIR=${BUILD_TMP}"
          } >> "${GITHUB_ENV}"

      - name: Read RPC version
        run: |
          source .github/workflows/scripts/rpc_version.env
          echo "RPC_VERSION=$RPC_VERSION" >> $GITHUB_ENV

      - name: Set reference data dir based on branch
        run: |
          # For pull_request events base_ref is the target branch name; for push/dispatch parse from ref.
          BRANCH="$GITHUB_BASE_REF"
          if [ -z "$BRANCH" ]; then
            BRANCH="$GITHUB_REF"
            BRANCH="${BRANCH#refs/heads/}"
          fi
          if [[ "$BRANCH" == release/* ]]; then
            VERSION="${BRANCH#release/}"
            echo "ERIGON_REFERENCE_DATA_DIR=/opt/erigon-versions/gnosis-reference-version-${VERSION}/datadir" >> $GITHUB_ENV
          else
            echo "ERIGON_REFERENCE_DATA_DIR=/opt/erigon-versions/gnosis-reference-version/datadir" >> $GITHUB_ENV
          fi

      - name: Clean Erigon Build Directory
        run: |
          make clean

      - name: Build Erigon RPCDaemon and integration
        run: |
          make rpcdaemon integration
        working-directory: ${{ github.workspace }}

      - name: Pause the Erigon instance dedicated to db maintenance
        run: |
          python3 $ERIGON_QA_PATH/test_system/db-producer/pause_production.py || true

      - name: Restore rpc-tests cache
        uses: actions/cache@v6
        with:
          path: ${{ runner.workspace }}/rpc-tests
          key: rpc-tests-${{ runner.os }}-${{ runner.arch }}-${{ env.RPC_VERSION }}

      - name: Run RPC Integration Tests
        id: test_step
        env:
          RUNNER_WS: ${{ runner.workspace }}
        run: |
          commit=$(git -C "$RUNNER_WS/erigon" rev-parse --short HEAD)
          TEST_RESULT_DIR="$RPC_PAST_TEST_DIR/gnosis_$(date +%Y%m%d_%H%M%S)_integration_${commit}_http"
          echo "TEST_RESULT_DIR=$TEST_RESULT_DIR" >> $GITHUB_ENV

          set +e # Disable exit on error for test run
          "$RUNNER_WS/erigon/.github/workflows/scripts/run_rpc_tests_local.sh" \
            --datadir "$ERIGON_REFERENCE_DATA_DIR" \
            --chain "$CHAIN" \
            --workspace "$RUNNER_WS" \
            --result-dir "$TEST_RESULT_DIR" \
            --backup-dir "$ERIGON_TESTBED_AREA/chaindata-prev"
          test_exit_status=$? # Capture test runner script exit status
          set -e # Re-enable exit on error after test run

          echo "test_executed=true" >> $GITHUB_OUTPUT

          echo
          if [ $test_exit_status -eq 0 ]; then
            echo "RPC tests completed successfully"
            echo "TEST_RESULT=success" >> "$GITHUB_OUTPUT"
          else
            echo "::error::Error detected during RPC tests: some tests failed, check the logs or the artifacts for more details"
            echo "TEST_RESULT=failure" >> "$GITHUB_OUTPUT"
            exit 1
          fi

      - name: Generate Summary
        if: always()
        env:
          RESULT: ${{ steps.test_step.outputs.TEST_RESULT || job.status }}
        run: |
          # Render structured results (which tests failed + overall stats) into the
          # run summary page. The reporter never fails the job and always prints
          # something, even when the run died before producing a report.
          SUMMARY=$(python3 "$GITHUB_WORKSPACE/.github/workflows/scripts/render_rpc_summary.py" \
            --result-dir "$TEST_RESULT_DIR" \
            --workflow "$GITHUB_WORKFLOW" \
            --chain "$CHAIN" \
            --result "$RESULT")
          printf '%s\n' "$SUMMARY"
          printf '%s\n' "$SUMMARY" >> "$GITHUB_STEP_SUMMARY"
          mkdir -p "$TEST_RESULT_DIR" 2>/dev/null && printf '%s\n' "$SUMMARY" > "$TEST_RESULT_DIR/summary.md" || true

      - name: Resume the Erigon instance dedicated to db maintenance
        if: always()
        run: |
          python3 $ERIGON_QA_PATH/test_system/db-producer/resume_production.py || true

      - name: Upload test results
        if: always() && steps.test_step.outputs.test_executed == 'true'
        uses: actions/upload-artifact@v7
        with:
          name: test-results-gnosis
          path: ${{ env.TEST_RESULT_DIR }}

      - name: Save test results
        if: always() && steps.test_step.outputs.test_executed == 'true'
        working-directory: ${{ github.workspace }}
        env:
          TEST_RESULT: ${{ steps.test_step.outputs.TEST_RESULT }}
        run: |
          db_version=$(python3 $ERIGON_QA_PATH/test_system/qa-tests/uploads/prod_info.py $ERIGON_REFERENCE_DATA_DIR/../production.ini production erigon_repo_commit)
          if [ -z "$db_version" ]; then
            db_version="no-version"
          fi
          
          python3 $ERIGON_QA_PATH/test_system/qa-tests/uploads/upload_test_results.py \
            --repo erigon \
            --commit $(git rev-parse HEAD) \
            --branch "$GITHUB_REF_NAME" \
            --test_name rpc-integration-tests \
            --chain $CHAIN \
            --runner "$RUNNER_NAME" \
            --db_version $db_version \
            --outcome $TEST_RESULT \
            --result_file $TEST_RESULT_DIR/results/test_report.json

      - name: Action to check failure condition
        if: failure()
        env:
          TEST_EXECUTED: ${{ steps.test_step.outputs.test_executed }}
        run: |
          if [ "$TEST_EXECUTED" != "true" ]; then
            echo "::error::Test not executed, workflow failed for infrastructure reasons"
          fi
          exit 1

      - name: Action for Success
        if: steps.test_step.outputs.TEST_RESULT == 'success'
        run: echo "::notice::Tests completed successfully"

      - name: Clean up job-scoped build temp dir
        if: always()
        run: |
          # Only delete a path of the exact shape we created under RUNNER_TEMP; never a bare/empty var.
          case "${BUILD_TMP}" in
            "${RUNNER_TEMP}/erigon-build-tmp-"*)
              rm -rf -- "${BUILD_TMP}"
              ;;
            *)
              echo "Skipping cleanup: BUILD_TMP='${BUILD_TMP:-}' is empty or unexpected"
              ;;
          esac