run-e2e-tests.yml

on:
  workflow_call:
    inputs:
      db-type:
        required: true
        type: string
      redis_enabled:
        required: true
        type: boolean
      python-version:
        required: true
        type: string
      is-fork:
        required: true
        type: boolean
      backend-image-name:
        required: true
        type: string
      frontend-image-name:
        required: true
        type: string

jobs:
  # Run tests with all services in one job
  run-tests:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
    env:
      REDIS: ${{ inputs.redis_enabled }}
      REDIS_HOST: keep-redis
      REDIS_PORT: 6379
      BACKEND_IMAGE: ${{ inputs.backend-image-name }}
      FRONTEND_IMAGE: ${{ inputs.frontend-image-name }}
    steps:
      - name: Checkout
        uses: actions/checkout@v3

      - name: Login to GitHub Container Registry
        if: ${{ inputs.is-fork != true }}
        uses: docker/login-action@v2
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Set up Python ${{ inputs.python-version }}
        uses: actions/setup-python@v4
        with:
          python-version: ${{ inputs.python-version }}

      - name: Install Poetry
        uses: snok/install-poetry@v1
        with:
          virtualenvs-create: true
          virtualenvs-in-project: true

      - name: Restore dependencies cache
        id: cache-deps
        uses: actions/cache@v4.2.0
        with:
          path: .venv
          key: pydeps-${{ hashFiles('**/poetry.lock') }}

      # Always install dependencies to ensure venv is valid
      # When cached, this completes quickly; when broken, this fixes it
      - name: Install dependencies using poetry
        run: poetry install --no-interaction --no-root --with dev

      - name: Get Playwright version from poetry.lock
        id: playwright-version
        run: |
          PLAYWRIGHT_VERSION=$(grep "playwright" poetry.lock -A 5 | grep "version" | head -n 1 | cut -d'"' -f2)
          echo "version=$PLAYWRIGHT_VERSION" >> $GITHUB_OUTPUT

      - name: Cache Playwright browsers
        id: playwright-cache
        uses: actions/cache@v4.2.0
        with:
          path: ~/.cache/ms-playwright
          key: playwright-${{ steps.playwright-version.outputs.version }}

      - name: Install Playwright and dependencies
        if: steps.playwright-cache.outputs.cache-hit != 'true'
        run: |
          poetry run playwright install --with-deps

      # For forks: Build images locally again since they don't persist between jobs
      - name: Set up Docker Buildx
        if: ${{ inputs.is-fork == true }}
        id: buildx
        uses: docker/setup-buildx-action@v2

      - name: Rebuild frontend image locally for fork PRs
        if: ${{ inputs.is-fork == true }}
        uses: docker/build-push-action@v4
        with:
          context: keep-ui
          file: ./docker/Dockerfile.ui
          push: false
          load: true
          tags: |
            keep-frontend:local
          cache-from: type=gha
          cache-to: type=gha,mode=max
          build-args: |
            BUILDKIT_INLINE_CACHE=1

      - name: Rebuild backend image locally for fork PRs
        if: ${{ inputs.is-fork == true }}
        uses: docker/build-push-action@v4
        with:
          context: .
          file: ./docker/Dockerfile.api
          push: false
          load: true
          tags: |
            keep-backend:local
          cache-from: type=gha
          cache-to: type=gha,mode=max
          build-args: |
            BUILDKIT_INLINE_CACHE=1

      # Create a modified compose file with our built images
      - name: Create modified docker-compose file with built images
        run: |
          cp tests/e2e_tests/docker-compose-e2e-${{ inputs.db-type }}.yml tests/e2e_tests/docker-compose-modified.yml

          # Replace image placeholders with actual image references
          sed -i "s|%KEEPFRONTEND_IMAGE%|${{ env.FRONTEND_IMAGE }}|g" tests/e2e_tests/docker-compose-modified.yml
          sed -i "s|%KEEPBACKEND_IMAGE%|${{ env.BACKEND_IMAGE }}|g" tests/e2e_tests/docker-compose-modified.yml

          # cat the modified file for debugging
          cat tests/e2e_tests/docker-compose-modified.yml

      # Start ALL services in one go
      - name: Start ALL services
        run: |
          echo "Starting ALL services for ${{ inputs.db-type }}..."

          # Pull the required images first (only needed for non-fork builds)
          if [[ "${{ inputs.is-fork }}" != "true" ]]; then
            docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml pull
          fi

          # Start all services together
          docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml up -d

          # Show running containers
          docker ps

          # Show the images sha of the running containers
          docker images

      # Wait for all services to be ready
      - name: Wait for services to be ready
        run: |
          # Function for exponential backoff
          function wait_for_service() {
            local service_name=$1
            local check_command=$2
            local max_attempts=$3
            local compose_service=$4  # Docker Compose service name
            local attempt=0
            local wait_time=1

            echo "Waiting for $service_name to be ready..."
            until eval "$check_command"; do
              if [ "$attempt" -ge "$max_attempts" ]; then
                echo "Max attempts reached, exiting..."
                # Show final logs before exiting
                if [ ! -z "$compose_service" ]; then
                  echo "===== FINAL LOGS FOR ON ERROR EXIT $compose_service ====="
                  docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml logs $compose_service
                  echo "=========================================="
                fi
                exit 1
              fi

              echo "Waiting for $service_name... (Attempt: $((attempt+1)), waiting ${wait_time}s)"

              # Print logs using docker compose
              if [ ! -z "$compose_service" ]; then
                echo "===== RECENT LOGS FOR $compose_service ====="
                docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml logs $compose_service --tail 100
                echo "=========================================="
              fi

              attempt=$((attempt+1))
              sleep $wait_time
              # Exponential backoff with max of 8 seconds
              wait_time=$((wait_time * 2 > 8 ? 8 : wait_time * 2))
            done
            echo "$service_name is ready!"

            # last time, print logs using docker compose
            if [ ! -z "$compose_service" ]; then
              echo "===== FINAL LOGS FOR $compose_service ====="
              docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml logs $compose_service --tail 100
              echo "=========================================="
            fi
          }

          # Database checks
          if [ "${{ inputs.db-type }}" == "mysql" ]; then
            wait_for_service "MySQL Database" "docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml exec -T keep-database mysqladmin ping -h \"localhost\" --silent" 10 "keep-database"
            wait_for_service "MySQL Database (DB AUTH)" "docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml exec -T keep-database-db-auth mysqladmin ping -h \"localhost\" --silent" 10 "keep-database-db-auth"
          elif [ "${{ inputs.db-type }}" == "postgres" ]; then
            wait_for_service "Postgres Database" "docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml exec -T keep-database pg_isready -h localhost -U keepuser" 10 "keep-database"
            wait_for_service "Postgres Database (DB AUTH)" "docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml exec -T keep-database-db-auth pg_isready -h localhost -U keepuser" 10 "keep-database-db-auth"
          fi

          # Wait for services with health checks
          wait_for_service "Keep backend" "curl --output /dev/null --silent --fail http://localhost:8080/healthcheck" 15 "keep-backend"
          wait_for_service "Keep backend (DB AUTH)" "curl --output /dev/null --silent --fail http://localhost:8081/healthcheck" 15 "keep-backend-db-auth"
          wait_for_service "Keep frontend" "curl --output /dev/null --silent --fail http://localhost:3000/" 15 "keep-frontend"
          wait_for_service "Keep frontend (DB AUTH)" "curl --output /dev/null --silent --fail http://localhost:3001/" 15 "keep-frontend-db-auth"

          # Give Prometheus and Grafana extra time to initialize
          # (using direct curl commands instead of container exec)
          echo "Waiting for Prometheus to be ready..."
          MAX_ATTEMPTS=15
          for i in $(seq 1 $MAX_ATTEMPTS); do
            if curl --output /dev/null --silent --fail http://localhost:9090/-/healthy; then
              echo "Prometheus is ready!"
              break
            elif [ $i -eq $MAX_ATTEMPTS ]; then
              echo "Prometheus did not become ready in time, but continuing..."
              docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml logs prometheus-server-for-test-target --tail 50
            else
              echo "Waiting for Prometheus... Attempt $i/$MAX_ATTEMPTS"
              sleep 5
            fi
          done

          echo "Waiting for Grafana to be ready..."
          MAX_ATTEMPTS=15
          for i in $(seq 1 $MAX_ATTEMPTS); do
            if curl --output /dev/null --silent --fail http://localhost:3002/api/health; then
              echo "Grafana is ready!"
              break
            elif [ $i -eq $MAX_ATTEMPTS ]; then
              echo "Grafana did not become ready in time, but continuing..."
              docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml logs grafana --tail 50
            else
              echo "Waiting for Grafana... Attempt $i/$MAX_ATTEMPTS"
              sleep 5
            fi
          done

          # Give everything a bit more time to stabilize
          echo "Giving services additional time to stabilize..."
          sleep 10

      # Debug the environment before running tests
      - name: Debug environment
        run: |
          echo "Checking all container status..."
          docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml ps

          echo "Network information:"
          docker network ls
          docker network inspect keep_default || true

          echo "Testing Prometheus API..."
          curl -v http://localhost:9090/api/v1/status/config || echo "Prometheus API not responding, but continuing..."

          echo "Testing Grafana API..."
          curl -v http://localhost:3002/api/health || echo "Grafana API not responding, but continuing..."

          echo "Test Keep Frontend..."
          curl -v http://localhost:3000/ || echo "Keep Frontend not responding, but continuing..."

          echo "Test Keep Frontend with DB Auth..."
          curl -v http://localhost:3001/ || echo "Keep Frontend with DB Auth not responding, but continuing..."

          echo "Listing available ports:"
          netstat -tuln | grep -E '3000|3001|3002|8080|8081|9090'

      # Run e2e tests
      - name: Run e2e tests and report coverage
        run: |
          echo "Running tests..."
          poetry run coverage run --branch -m pytest -v tests/e2e_tests/ -n 4 --dist=loadfile
          echo "Tests completed!"

      - name: Convert coverage results to JSON (for CodeCov support)
        run: poetry run coverage json --omit="keep/providers/*"

      - name: Upload coverage reports to Codecov
        uses: codecov/codecov-action@v3
        with:
          fail_ci_if_error: false
          files: coverage.json
          verbose: true

      # Collect logs
      - name: Dump logs
        if: always()
        run: |
          docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml logs keep-backend > backend_logs-${{ inputs.db-type }}.txt
          docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml logs keep-frontend > frontend_logs-${{ inputs.db-type }}.txt
          docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml logs keep-backend-db-auth > backend_logs-${{ inputs.db-type }}-db-auth.txt
          docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml logs keep-frontend-db-auth > frontend_logs-${{ inputs.db-type }}-db-auth.txt
          docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml logs prometheus-server-for-test-target > prometheus_logs-${{ inputs.db-type }}.txt
          docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml logs grafana > grafana_logs-${{ inputs.db-type }}.txt
        continue-on-error: true

      # Upload artifacts
      - name: Upload test artifacts on failure
        if: always()
        uses: actions/upload-artifact@v4.4.3
        with:
          name: test-artifacts-db-${{ inputs.db-type }}-redis-${{ inputs.redis_enabled }}
          path: |
            playwright_dump_*.html
            playwright_dump_*.png
            playwright_dump_*.txt
            playwright_dump_*.json
            backend_logs-${{ inputs.db-type }}.txt
            frontend_logs-${{ inputs.db-type }}.txt
            backend_logs-${{ inputs.db-type }}-db-auth.txt
            frontend_logs-${{ inputs.db-type }}-db-auth.txt
            prometheus_logs-${{ inputs.db-type }}.txt
            grafana_logs-${{ inputs.db-type }}.txt
        continue-on-error: true

      # Tear down environment
      - name: Tear down environment
        if: always()
        run: |
          docker compose -p keep --project-directory . -f tests/e2e_tests/docker-compose-modified.yml down