reusable-e2e.yml

on:
  workflow_call:
    inputs:
      postgres_img:
        description: "URL of the Postgres image to test"
        required: true
        type: string
      major_version:
        description: "PostgreSQL major version"
        required: true
        type: string
      cnpg_branch:
        description: "Name of the branch/tag used to build & load the operator"
        required: false
        type: string
        default: "main"
      test_depth:
        description: 'E2E test level: 0(highest) to 4(lowest)'
        required: false
        type: string
        default: "4"
      feature_type:
        description: 'E2E feature type filter'
        required: false
        type: string
        default: ""

# set up environment variables to be used across all the jobs
env:
  KIND_VERSION: "v0.31.0"
  K8S_VERSION: "v1.35.1"
  REGISTRY: "ghcr.io/${{ github.repository_owner }}/postgresql-trunk"

defaults:
  run:
    # default failure handling for shell scripts in 'run' steps
    shell: 'bash -Eeuo pipefail -x {0}'

permissions: {}

jobs:
  e2e-local:
    name: Run E2E on local executors
    runs-on: ${{ github.repository_owner == 'cloudnative-pg' && 'ubuntu-latest-16-cores' || 'ubuntu-24.04' }}
    permissions:
      packages: write
    env:
      TEST_DEPTH: ${{ inputs.test_depth }}
      FEATURE_TYPE: ${{ inputs.feature_type }}

      POSTGRES_VERSION: ${{ inputs.major_version }}
      POSTGRES_IMG: ${{ inputs.postgres_img }}
      POSTGRES_KIND: "PostgreSQL"
      POSTGRES_MAJOR_UPGRADE_IMAGE_REGISTRY: "ghcr.io/${{ github.repository_owner }}/postgresql-trunk"
      POSTGRES_MAJOR_UPGRADE_SKIP_ARCHIVE_SCENARIO: true

      DOCKER_SERVER: ghcr.io
      DOCKER_USERNAME: ${{ github.actor }}
      DOCKER_PASSWORD: ${{ secrets.GITHUB_TOKEN }}

      ID: "local"
      TEST_UPGRADE_TO_V1: false
      DEBUG: "true"
      BUILD_IMAGE: "true"
      E2E_DEFAULT_STORAGE_CLASS: standard
      E2E_CSI_STORAGE_CLASS: csi-hostpath-sc
      E2E_DEFAULT_VOLUMESNAPSHOT_CLASS: csi-hostpath-snapclass
      LOG_DIR: ${{ github.workspace }}/kind-logs/
      DOCKER_REGISTRY_MIRROR: https://mirror.gcr.io
      TEST_CLOUD_VENDOR: "local"
    steps:
      - name: Cleanup Disk
        uses: jlumbroso/free-disk-space@main
        with:
          android: true
          dotnet: true
          haskell: true
          tool-cache: true
          large-packages: false
          swap-storage: false

      - name: Cleanup docker cache
        run: |
          echo "-------------Disk info before cleanup----------------"
          df -h
          echo "-----------------------------------------------------"
          docker system prune -a -f
          echo "-------------Disk info after cleanup----------------"
          df -h
          echo "-----------------------------------------------------"

      - name: Checkout
        uses: actions/checkout@v6
        with:
          repository: cloudnative-pg/cloudnative-pg
          ref: ${{ inputs.cnpg_branch }}
          fetch-depth: 0

      - name: Install Go
        uses: actions/setup-go@v6
        with:
          go-version-file: go.mod
          check-latest: true

      - name: Set GoReleaser environment
        run: |
          echo GOPATH=$(go env GOPATH) >> $GITHUB_ENV
          echo PWD=$(pwd) >> $GITHUB_ENV

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v4

      - name: Install Kind
        uses: helm/kind-action@v1.14.0
        with:
          install_only: true
          version: ${{ env.KIND_VERSION }}
          kubectl_version: ${{ env.K8S_VERSION }}

      - name: Log in to the GitHub Container registry
        uses: docker/login-action@v4
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      # The version of operator to upgrade FROM, in the rolling upgrade E2E test
      - name: Retag the image to create E2E_PRE_ROLLING_UPDATE_IMG
        env:
          INPUT_MAJOR_VERSION: ${{ inputs.major_version }}
          INPUT_POSTGRES_IMG: ${{ inputs.postgres_img }}
        run: |
          E2E_PRE_ROLLING_UPDATE_IMG="${REGISTRY}:${INPUT_MAJOR_VERSION}-rolling-upgrade-e2e-${GITHUB_RUN_NUMBER}"
          docker pull "${INPUT_POSTGRES_IMG}"
          docker tag "${INPUT_POSTGRES_IMG}" $E2E_PRE_ROLLING_UPDATE_IMG
          docker push $E2E_PRE_ROLLING_UPDATE_IMG
          echo "E2E_PRE_ROLLING_UPDATE_IMG=$E2E_PRE_ROLLING_UPDATE_IMG" >> $GITHUB_ENV

      - name: Setting up defaults
        run: |
          # Exlude backup/recovery and image-volume tests
          if [ -z "${FEATURE_TYPE}" ]; then
            echo "FEATURE_TYPE=!(backup-restore || image-volume-extensions)" >> $GITHUB_ENV
          else
            echo "FEATURE_TYPE=!(backup-restore || image-volume-extensions) && ${FEATURE_TYPE}" >> $GITHUB_ENV
          fi

      - name: Run Kind End-to-End tests
        run: make e2e-test-kind

        # Summarize the failed E2E test cases if there are any
      - name: Report failed E2E tests
        if: failure()
        run: |
          set +x
          chmod +x .github/report-failed-test.sh
          ./.github/report-failed-test.sh

        # Create an individual artifact for each E2E test, which will be used to
        # generate E2E test summary in the follow-up job 'summarize-e2e-tests'
      - name: Create individual artifact for each E2E test
        if: (always() && !cancelled())
        env:
          RUNNER: "${{ env.ID }}"
          POSTGRES_VERSION: "${{ env.PG_MAJOR }}"
          RUN_ID: "${{ github.run_id }}"
          MATRIX: "${{ env.ID }}-${{ env.POSTGRES_KIND }}-${{ env.PG_MAJOR }}"
          REPOSITORY: "${{ github.repository }}"
          BRANCH_NAME: "${GITHUB_REF#refs/heads/}"
          GIT_REF: "${{ github.ref_name }}"
        run: |
          set +x
          python .github/generate-test-artifacts.py \
            -o "testartifacts-${ID}" \
            -f tests/e2e/out/report.json \
            --environment=true
          if [ -f tests/e2e/out/upgrade_report.json ]; then
            python .github/generate-test-artifacts.py \
              -o "testartifacts-${ID}" \
              -f tests/e2e/out/upgrade_report.json \
              --environment=true
          fi

      - name: Archive test artifacts
        if: (always() && !cancelled())
        uses: actions/upload-artifact@v7
        with:
          name: testartifacts-local
          path: testartifacts-${{ env.ID }}/
          retention-days: 7

      - name: Cleanup test artifacts
        if: always()
        run:
          rm -rf testartifacts-${{ env.ID }}/

      # Delete report.json after the analysis. File should always exist.
      # Delete upgrade_report.json. It may not exist depending on test level.
      - name: Cleanup ginkgo JSON report
        if: always()
        run: |
          if [ -f tests/e2e/out/upgrade_report.json ]; then
            rm tests/e2e/out/upgrade_report.json
          fi
          if [ -f tests/e2e/out/report.json ]; then
            rm tests/e2e/out/report.json
          fi

      # Archive logs for failed test cases if there are any
      - name: Archive Kind logs
        if: failure()
        uses: actions/upload-artifact@v7
        with:
          name: kind-logs-${{ env.ID }}
          path: kind-logs/
          retention-days: 7

      - name: Archive e2e failure contexts
        if: failure()
        uses: actions/upload-artifact@v7
        with:
          name: test-failure-contexts-${{ env.ID }}
          path: |
            tests/*/out/
          retention-days: 7
          if-no-files-found: ignore

      # Archive Cluster logs
      - name: Archive e2e logs
        if: failure()
        uses: actions/upload-artifact@v7
        with:
          name: cluster-logs-${{ env.ID }}
          path: |
            tests/e2e/cluster_logs/**
          retention-days: 7
          if-no-files-found: ignore

  # Summarize E2E test results, display in the GitHub 'summary' view
  summarize-e2e-tests:
    name: E2E test suite
    needs:
      - e2e-local
    if: |
      always() && !cancelled() &&
      (
        needs.e2e-local.result == 'success' ||
        needs.e2e-local.result == 'failure'
      )
    runs-on: ubuntu-24.04
    steps:
      - name: Create a directory for the artifacts
        run: mkdir test-artifacts

      - name: Download all artifacts to the directory
        uses: actions/download-artifact@v8
        with:
          path: test-artifacts
          pattern: testartifacts-*
          merge-multiple: true

      - name: Display the structure of the artifact folder
        run: ls -R test-artifacts

      - name: Compute the E2E test summary
        uses: cloudnative-pg/ciclops@v1.3.2
        with:
          artifact_directory: test-artifacts

      - name: Delete the downloaded files
        run: rm -rf test-artifacts