_ci-e2e-tauri-all-providers.reusable.yml

name: Tauri E2E Tests - All Providers

description: 'Runs Tauri E2E tests for all WebDriver providers (official, embedded, CrabNebula) sequentially on a single runner'

permissions:
  contents: read

on:
  workflow_call:
    inputs:
      os:
        description: 'Operating system to run tests on'
        required: true
        type: string
      node-version:
        description: 'Node.js version to use for testing'
        required: true
        type: string
      test-type:
        description: 'Test type (standard, window, multiremote, standalone, deeplink)'
        type: string
        default: 'standard'
      build_id:
        description: 'Build ID from the build job'
        type: string
        required: false
      artifact_size:
        description: 'Size of the build artifact in bytes'
        type: string
        required: false
      cache_key:
        description: 'Cache key to use for downloading package artifacts'
        type: string
        required: false
      tauri_cache_key:
        description: 'Cache key to use for downloading Tauri app binaries'
        type: string
        required: false

env:
  TURBO_TELEMETRY_DISABLED: 1
  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
  TURBO_TEAM: ${{ secrets.TURBO_TEAM }}

jobs:
  e2e-tauri:
    name: Tauri E2E Tests
    runs-on: ${{ inputs.os }}
    steps:
      # ══════════════════════════════════════════════════════════════
      # SHARED SETUP (runs once, reused by all providers)
      # ══════════════════════════════════════════════════════════════

      - name: 👷 Checkout Repository
        uses: actions/checkout@v6
        with:
          ssh-key: ${{ secrets.DEPLOY_KEY }}

      - name: 🛠️ Setup Development Environment
        uses: ./.github/workflows/actions/setup-workspace
        with:
          node-version: ${{ inputs.node-version }}

      - name: 🔧 Fix ARM64 Package Sources (Linux)
        if: runner.os == 'Linux' && runner.arch == 'ARM64'
        shell: bash
        run: |
          echo "Fixing ARM64 package sources for Ubuntu..."
          echo "deb [arch=arm64] http://ports.ubuntu.com/ubuntu-ports/ jammy main restricted universe multiverse" | sudo tee /etc/apt/sources.list.d/arm64-jammy.list > /dev/null
          echo "deb [arch=arm64] http://ports.ubuntu.com/ubuntu-ports/ jammy-updates main restricted universe multiverse" | sudo tee -a /etc/apt/sources.list.d/arm64-jammy.list > /dev/null
          echo "deb [arch=arm64] http://ports.ubuntu.com/ubuntu-ports/ jammy-backports main restricted universe multiverse" | sudo tee -a /etc/apt/sources.list.d/arm64-jammy.list > /dev/null
          echo "deb [arch=arm64] http://ports.ubuntu.com/ubuntu-ports/ jammy-security main restricted universe multiverse" | sudo tee -a /etc/apt/sources.list.d/arm64-jammy.list > /dev/null

          sudo sed -i -e 's/^deb http/deb [arch=amd64] http/' /etc/apt/sources.list
          sudo sed -i -e 's/^deb mirror/deb [arch=amd64] mirror/' /etc/apt/sources.list

          sudo apt-get update

      - name: 🦀 Install Tauri Runtime Dependencies (Linux)
        if: runner.os == 'Linux'
        shell: bash
        run: |
          echo "Installing Tauri runtime dependencies for Linux..."
          if [ "$(uname -m)" != "aarch64" ]; then
            echo "deb http://archive.ubuntu.com/ubuntu jammy main universe" | sudo tee -a /etc/apt/sources.list > /dev/null
          fi
          sudo apt-get update
          sudo apt-get --fix-broken install -y || true

          sudo apt-get install -y \
            libwebkit2gtk-4.1-0 \
            libgtk-3-0t64 \
            libayatana-appindicator3-1

      # Rust needed for official provider (tauri-driver auto-install)
      # Only installed on Linux/Windows where official provider runs
      - name: 🦀 Setup Rust (for tauri-driver auto-install)
        if: inputs.os != 'macos-latest' && inputs.os != 'macos-15-intel'
        uses: dtolnay/rust-toolchain@stable
        with:
          components: rustfmt

      # WebKitWebDriver needed for official + crabnebula providers on Linux
      - name: 🌐 Install WebKit WebDriver (Linux)
        if: runner.os == 'Linux'
        shell: bash
        run: |
          echo "Installing WebKit WebDriver for Linux..."
          sudo apt-get install -y webkit2gtk-driver
          which WebKitWebDriver || echo "WebKitWebDriver not found in PATH"
          WebKitWebDriver --version || echo "WebKitWebDriver version check failed"

      - name: 📦 Download Package Build Artifacts
        uses: ./.github/workflows/actions/download-archive
        with:
          name: wdio-desktop-mobile
          path: wdio-desktop-mobile-build
          filename: artifact.zip
          cache_key_prefix: wdio-desktop-build
          exact_cache_key: ${{ inputs.cache_key || github.run_id && format('{0}-{1}-{2}-{3}{4}', 'Linux', 'wdio-desktop-build', 'wdio-desktop-mobile', github.run_id, github.run_attempt > 1 && format('-rerun{0}', github.run_attempt) || '') || '' }}

      - name: 📦 Download Tauri E2E App Binary
        uses: ./.github/workflows/actions/download-archive
        with:
          name: tauri-e2e-app-${{ runner.os }}-${{ runner.arch }}
          path: tauri-e2e-app-${{ runner.os }}-${{ runner.arch }}
          filename: artifact.zip
          cache_key_prefix: tauri-e2e-app
          exact_cache_key: ${{ inputs.tauri_cache_key }}

      - name: ✅ Verify Tauri Binaries
        shell: bash
        run: |
          echo "Checking for Tauri binaries in fixtures/e2e-apps/tauri/src-tauri/target/"

          if [ ! -d "fixtures/e2e-apps/tauri" ]; then
            echo "::error::fixtures/e2e-apps/tauri directory not found!"
            exit 1
          fi

          TARGET_DIRS=$(find fixtures/e2e-apps/tauri -name "target" -type d 2>/dev/null || true)

          if [ -z "$TARGET_DIRS" ]; then
            echo "::error::No target directories found! Binaries were not extracted correctly."
            echo "Directory contents:"
            ls -la fixtures/e2e-apps/tauri/ || true
            ls -la fixtures/e2e-apps/tauri/src-tauri/ || true
            exit 1
          fi

          echo "✅ Found target directories:"
          echo "$TARGET_DIRS"

          BINARY_COUNT=0
          for target_dir in $TARGET_DIRS; do
            if [ "${{ runner.os }}" = "Windows" ]; then
              if compgen -G "$target_dir/debug/*.exe" > /dev/null 2>&1; then
                BINARY_COUNT=$((BINARY_COUNT + 1))
                echo "  ✅ Found Windows binary in $target_dir/debug/"
              fi
            elif [ "${{ runner.os }}" = "macOS" ]; then
              if find "$target_dir/debug" -maxdepth 1 -type f -perm +111 2>/dev/null | grep -q .; then
                BINARY_COUNT=$((BINARY_COUNT + 1))
                echo "  ✅ Found macOS raw binary in $target_dir/debug/"
              else
                for search_path in "$target_dir/debug/bundle/macos" "$target_dir/aarch64-apple-darwin/debug/bundle/macos" "$target_dir/x86_64-apple-darwin/debug/bundle/macos" "$target_dir/universal-apple-darwin/debug/bundle/macos"; do
                  if compgen -G "$search_path/*.app" > /dev/null 2>&1; then
                    BINARY_COUNT=$((BINARY_COUNT + 1))
                    echo "  ✅ Found macOS app bundle in $search_path/"
                    break
                  fi
                done
              fi
            else
              if find "$target_dir/debug" -maxdepth 1 -type f -executable 2>/dev/null | grep -q .; then
                BINARY_COUNT=$((BINARY_COUNT + 1))
                echo "  ✅ Found binary in $target_dir/debug/"
              fi
            fi
          done

          if [ "$BINARY_COUNT" -eq 0 ]; then
            echo "::error::No binaries found in target directories!"
            echo ""
            echo "Directory structure for debugging:"
            for target_dir in $TARGET_DIRS; do
              echo "=== $target_dir ==="
              ls -la "$target_dir/" 2>/dev/null | head -10 || echo "Cannot list directory"
              echo ""
              echo "=== $target_dir/debug/ ==="
              ls -la "$target_dir/debug/" 2>/dev/null | head -20 || echo "Cannot list debug directory"
              if [ "${{ runner.os }}" = "macOS" ]; then
                echo ""
                echo "Looking for .app bundles..."
                find "$target_dir" -name "*.app" -type d 2>/dev/null | head -5 || echo "No .app bundles found"
                echo ""
                echo "Looking for bundle directories..."
                find "$target_dir" -type d -name "bundle" 2>/dev/null | head -5 || echo "No bundle directories found"
                if [ -d "$target_dir/debug/bundle" ]; then
                  echo ""
                  echo "=== $target_dir/debug/bundle/ ==="
                  ls -la "$target_dir/debug/bundle/" 2>/dev/null || echo "Cannot list bundle directory"
                  if [ -d "$target_dir/debug/bundle/macos" ]; then
                    echo ""
                    echo "=== $target_dir/debug/bundle/macos/ ==="
                    ls -la "$target_dir/debug/bundle/macos/" 2>/dev/null || echo "Cannot list macos directory"
                  fi
                fi
              fi
            done
            exit 1
          fi

          echo "✅ Verification complete: Found $BINARY_COUNT app(s) with binaries"

      - name: 📊 Show Build Information
        if: inputs.build_id != '' && inputs.artifact_size != ''
        shell: bash
        run: |
          echo "::notice::Package build: ID=${{ inputs.build_id }}, Size=${{ inputs.artifact_size }} bytes"
          echo "::notice::Tauri binaries: Using pre-built binaries for ${{ runner.os }}"

      - name: 🔗 Setup Protocol Handlers
        shell: bash
        run: |
          echo "=== Protocol Handler Setup ==="
          echo "Runner OS: ${{ runner.os }}"
          echo "Working directory: $(pwd)"
          echo ""

          echo "Setting up protocol handler for: tauri"

          if [ "${{ runner.os }}" == "Windows" ]; then
            echo "Setting up Windows protocol handler..."

            echo "Checking if src-tauri/target directory exists..."
            ls -la ./fixtures/e2e-apps/tauri/src-tauri/target/ || echo "src-tauri/target/ not found"
            echo ""

            powershell -ExecutionPolicy Bypass -File ./fixtures/e2e-apps/tauri/scripts/setup-protocol-handler.ps1
            EXIT_CODE=$?

            if [ $EXIT_CODE -ne 0 ]; then
              echo "Error: Protocol handler setup failed for tauri with exit code $EXIT_CODE"
              exit 1
            fi

          elif [ "${{ runner.os }}" == "Linux" ]; then
            echo "Setting up Linux protocol handler..."

            echo "Checking if src-tauri/target directory exists..."
            ls -la ./fixtures/e2e-apps/tauri/src-tauri/target/ || echo "src-tauri/target/ not found"
            echo ""

            chmod +x ./fixtures/e2e-apps/tauri/scripts/setup-protocol-handler.sh
            ./fixtures/e2e-apps/tauri/scripts/setup-protocol-handler.sh
            EXIT_CODE=$?

            if [ $EXIT_CODE -ne 0 ]; then
              echo "Error: Protocol handler setup failed for tauri with exit code $EXIT_CODE"
              exit 1
            fi

          else
            echo "macOS: Protocol handlers are registered by the app itself via deep-link configuration"
            echo "No external setup needed - the app registers on first launch"
          fi

          echo ""
          echo "=== Protocol Handler Setup Complete ==="

      - name: 🔍 Verify Protocol Registration
        if: runner.os != 'macOS'
        shell: bash
        run: |
          echo "=== Protocol Registration Verification ==="

          if [ "${{ runner.os }}" == "Linux" ]; then
            echo "Linux: Checking xdg-mime registration..."
            xdg-mime query default x-scheme-handler/testapp || echo "WARNING: No handler registered for testapp://"

            echo ""
            echo "Checking .desktop file..."
            if [ -f "$HOME/.local/share/applications/tauri-e2e-app-testapp.desktop" ]; then
              echo "✅ Desktop file exists:"
              cat "$HOME/.local/share/applications/tauri-e2e-app-testapp.desktop"
            else
              echo "❌ Desktop file NOT found at ~/.local/share/applications/tauri-e2e-app-testapp.desktop"
            fi

            echo ""
            echo "Checking desktop database..."
            update-desktop-database "$HOME/.local/share/applications" 2>/dev/null || true

          elif [ "${{ runner.os }}" == "Windows" ]; then
            echo "Windows: Checking registry..."
            reg query "HKCR\testapp" 2>nul || echo "❌ Protocol NOT registered in HKCR\testapp"
            reg query "HKCR\testapp\shell\open\command" 2>nul || echo "❌ Command key NOT found"
          fi

          echo ""
          echo "=== Protocol Verification Complete ==="

      - name: 🪄 Generate Test Commands
        id: gen-test
        uses: actions/github-script@v9
        with:
          script: |
            const ALLOWED = ['standard', 'window', 'multiremote', 'standalone', 'deeplink'];
            const testType = '${{ inputs.test-type }}'.trim();
            if (!ALLOWED.includes(testType)) {
              core.setFailed(`Invalid test-type: "${testType}". Allowed: ${ALLOWED.join(', ')}`);
              return;
            }
            const suffix = testType !== 'standard' ? `:${testType}` : '';
            core.setOutput('official', `test:e2e:tauri-basic${suffix}`);
            core.setOutput('embedded', `test:e2e:tauri-basic-embedded${suffix}`);
            core.setOutput('crabnebula', `test:e2e:tauri-basic-crabnebula${suffix}`);

      # ══════════════════════════════════════════════════════════════
      # PROVIDER 1: OFFICIAL (tauri-driver) — skipped on macOS
      # ══════════════════════════════════════════════════════════════

      - name: 🧹 Cleanup [Official]
        if: inputs.os != 'macos-latest' && inputs.os != 'macos-15-intel'
        shell: bash
        run: |
          echo "Cleaning up before Official provider tests..."
          if [ "${{ runner.os }}" == "Windows" ]; then
            powershell -Command "Get-Process -Name 'tauri-driver','msedgedriver','tauri-e2e-app' -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue" || true
          else
            pkill -9 -f tauri-driver || true
            pkill -9 -f tauri-e2e-app || true
          fi

      - name: 🧪 E2E Tests [Official]
        id: test-official
        if: inputs.os != 'macos-latest' && inputs.os != 'macos-15-intel'
        continue-on-error: true
        shell: pwsh
        working-directory: e2e
        env:
          RUST_BACKTRACE: '1'
          NO_AT_BRIDGE: '1'
          DRIVER_PROVIDER: 'official'
        run: |
          if ($env:RUNNER_OS -eq "Linux") {
            xvfb-run --auto-servernum --server-args="-screen 0 1280x1024x16" `
              pnpm run ${{ steps.gen-test.outputs.official }}
          } else {
            pnpm run ${{ steps.gen-test.outputs.official }}
          }

      - name: 🧹 Post-cleanup [Official]
        if: always() && inputs.os != 'macos-latest' && inputs.os != 'macos-15-intel'
        shell: bash
        run: |
          echo "Cleaning up after Official provider tests..."
          if [ "${{ runner.os }}" == "Windows" ]; then
            powershell -Command "Get-Process -Name 'tauri-driver','msedgedriver','tauri-e2e-app' -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue" || true
          else
            pkill -9 -f tauri-driver || true
            pkill -9 -f msedgedriver || true
            pkill -9 -f tauri-e2e-app || true
          fi

      - name: 🐛 Debug Information [Official]
        if: always() && inputs.os != 'macos-latest' && inputs.os != 'macos-15-intel'
        shell: bash
        run: pnpm exec tsx e2e/scripts/show-logs.ts --provider official

      # ══════════════════════════════════════════════════════════════
      # PROVIDER 2: EMBEDDED (tauri-plugin-webdriver)
      # ══════════════════════════════════════════════════════════════

      - name: 🧹 Cleanup [Embedded]
        if: always()
        shell: bash
        run: |
          echo "Cleaning up before Embedded provider tests..."
          if [ "${{ runner.os }}" == "Windows" ]; then
            powershell -Command "Get-Process -Name 'tauri-e2e-app' -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue" || true
          else
            pkill -9 -f tauri-e2e-app || true
          fi

      - name: 🧪 E2E Tests [Embedded]
        id: test-embedded
        continue-on-error: true
        shell: pwsh
        working-directory: e2e
        env:
          RUST_BACKTRACE: '1'
          NO_AT_BRIDGE: '1'
          DRIVER_PROVIDER: 'embedded'
        run: |
          if ($env:RUNNER_OS -eq "Linux") {
            xvfb-run --auto-servernum --server-args="-screen 0 1280x1024x16" `
              pnpm run ${{ steps.gen-test.outputs.embedded }}
          } else {
            pnpm run ${{ steps.gen-test.outputs.embedded }}
          }

      - name: 🧹 Post-cleanup [Embedded]
        if: always()
        shell: bash
        run: |
          echo "Cleaning up after Embedded provider tests..."
          if [ "${{ runner.os }}" == "Windows" ]; then
            powershell -Command "Get-Process -Name 'tauri-e2e-app' -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue" || true
          else
            pkill -9 -f tauri-e2e-app || true
          fi

      - name: 🐛 Debug Information [Embedded]
        if: always()
        shell: bash
        run: pnpm exec tsx e2e/scripts/show-logs.ts --provider embedded

      # ══════════════════════════════════════════════════════════════
      # PROVIDER 3: CRABNEBULA
      # ══════════════════════════════════════════════════════════════

      - name: 🧹 Cleanup [CrabNebula]
        if: always()
        shell: bash
        run: |
          echo "Cleaning up before CrabNebula provider tests..."
          if [ "${{ runner.os }}" == "Windows" ]; then
            powershell -Command "Get-Process -Name 'tauri-e2e-app' -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue" || true
            powershell -Command "Get-Process -Name 'test-runner-backend' -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue" || true
            powershell -Command "Get-Process -Name 'tauri-driver' -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue" || true
          else
            pkill -9 -f tauri-e2e-app || true
            pkill -9 -f test-runner-backend || true
            pkill -9 -f tauri-driver || true
          fi

      - name: 🧪 E2E Tests [CrabNebula]
        id: test-crabnebula
        continue-on-error: true
        shell: pwsh
        working-directory: e2e
        env:
          RUST_BACKTRACE: '1'
          NO_AT_BRIDGE: '1'
          DRIVER_PROVIDER: 'crabnebula'
          CN_API_KEY: ${{ secrets.CN_API_KEY }}
        run: |
          if ($env:RUNNER_OS -eq "Linux") {
            xvfb-run --auto-servernum --server-args="-screen 0 1280x1024x16" `
              pnpm run ${{ steps.gen-test.outputs.crabnebula }}
          } else {
            pnpm run ${{ steps.gen-test.outputs.crabnebula }}
          }

      - name: 🧹 Post-cleanup [CrabNebula]
        if: always()
        shell: bash
        run: |
          echo "Cleaning up after CrabNebula provider tests..."
          if [ "${{ runner.os }}" == "Windows" ]; then
            powershell -Command "Get-Process -Name 'tauri-e2e-app' -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue" || true
            powershell -Command "Get-Process -Name 'test-runner-backend' -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue" || true
            powershell -Command "Get-Process -Name 'tauri-driver' -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue" || true
          else
            pkill -9 -f tauri-e2e-app || true
            pkill -9 -f test-runner-backend || true
            pkill -9 -f tauri-driver || true
          fi

      - name: 🐛 Debug Information [CrabNebula]
        if: always()
        shell: bash
        run: pnpm exec tsx e2e/scripts/show-logs.ts --provider crabnebula

      # ══════════════════════════════════════════════════════════════
      # REPORTING & ARTIFACTS
      # ══════════════════════════════════════════════════════════════

      - name: 📊 Provider Summary
        if: always()
        shell: bash
        run: |
          echo "## Tauri E2E Results — ${{ inputs.os }} / ${{ inputs.test-type }}" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "| Provider | Result |" >> $GITHUB_STEP_SUMMARY
          echo "|----------|--------|" >> $GITHUB_STEP_SUMMARY

          official="${{ steps.test-official.outcome }}"
          embedded="${{ steps.test-embedded.outcome }}"
          crabnebula="${{ steps.test-crabnebula.outcome }}"

          format_result() {
            local provider="$1" outcome="$2"
            case "$outcome" in
              success)   echo "| $provider | ✅ Passed |" >> $GITHUB_STEP_SUMMARY ;;
              failure)   echo "| $provider | ❌ Failed |" >> $GITHUB_STEP_SUMMARY ;;
              cancelled) echo "| $provider | ⚠️ Cancelled |" >> $GITHUB_STEP_SUMMARY ;;
              skipped|"") echo "| $provider | ⏭️ Skipped |" >> $GITHUB_STEP_SUMMARY ;;
              *)         echo "| $provider | ❓ $outcome |" >> $GITHUB_STEP_SUMMARY ;;
            esac
          }

          format_result "Official" "$official"
          format_result "Embedded" "$embedded"
          format_result "CrabNebula" "$crabnebula"

      - name: 📦 Upload Test Logs
        if: always()
        continue-on-error: true
        uses: actions/upload-artifact@v7
        with:
          name: e2e-tauri-logs-${{ inputs.os }}-${{ github.run_id }}-${{ github.run_attempt }}-${{ inputs.test-type }}
          path: e2e/logs/**/*.log
          retention-days: 90
          if-no-files-found: warn

      # Fail the job if any provider failed
      - name: ❌ Check Provider Results
        if: always()
        shell: bash
        run: |
          official="${{ steps.test-official.outcome }}"
          embedded="${{ steps.test-embedded.outcome }}"
          crabnebula="${{ steps.test-crabnebula.outcome }}"

          failed=false

          check_result() {
            local provider="$1" outcome="$2"
            case "$outcome" in
              success|skipped|"") ;;
              failure)
                echo "::error::$provider provider tests failed"
                failed=true ;;
              cancelled)
                echo "::error::$provider provider tests were cancelled"
                failed=true ;;
              *)
                echo "::error::$provider provider had unexpected outcome: $outcome"
                failed=true ;;
            esac
          }

          check_result "Official" "$official"
          check_result "Embedded" "$embedded"
          check_result "CrabNebula" "$crabnebula"

          if [ "$failed" = "true" ]; then
            exit 1
          fi
          echo "All providers passed"

      - name: 🐛 Debug Build on Failure
        if: failure()
        uses: goosewobbler/vscode-server-action@v1.5.0
        with:
          timeout: '300000'