vm-execution-tests.yml

name: VM Execution Tests

# NOTE: This workflow tests experimental VM execution features using Firecracker
# Firecracker is Linux-only - these tests will not work on macOS/Windows
# The scratchpad/firecracker-rust directory is gitignored (experimental code)
# Tests will skip gracefully if the directory is not present
# Triggered manually for adaptive concurrency testing

on:
  push:
    branches: [ main, develop, agent_system ]
    paths:
      - 'crates/terraphim_multi_agent/**'
      - 'scratchpad/firecracker-rust/**'
      - 'scripts/test-vm-execution.sh'
      - '.github/workflows/vm-execution-tests.yml'
  pull_request:
    branches: [ main, develop ]
    paths:
      - 'crates/terraphim_multi_agent/**'
      - 'scratchpad/firecracker-rust/**'
      - 'scripts/test-vm-execution.sh'
      - '.github/workflows/vm-execution-tests.yml'
  workflow_dispatch:  # Allow manual triggering

env:
  CARGO_TERM_COLOR: always
  RUST_BACKTRACE: 1
  RUST_LOG: info

jobs:
  unit-tests:
    name: Unit Tests
    runs-on: [self-hosted, linux, x64]
    timeout-minutes: 10

    steps:
    - name: Platform check
      run: |
        echo "⚠️ VM execution tests are Linux-only (Firecracker requirement)"
        echo "Running on: ubuntu-latest ✅"

    - name: Checkout code
      uses: actions/checkout@v6

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@stable
      with:
        toolchain: stable
        components: rustfmt, clippy

    - name: Cache cargo dependencies
      uses: actions/cache@v4
      with:
        path: |
          ~/.cargo/bin/
          ~/.cargo/registry/index/
          ~/.cargo/registry/cache/
          ~/.cargo/git/db/
          target/
        key: ${{ runner.os }}-cargo-unit-${{ hashFiles('**/Cargo.lock') }}
        restore-keys: |
          ${{ runner.os }}-cargo-unit-
          ${{ runner.os }}-cargo-

    - name: Check if fcctl-web exists
      id: check_fcctl_unit
      run: |
        if [ -d "scratchpad/firecracker-rust/fcctl-web" ]; then
          echo "exists=true" >> $GITHUB_OUTPUT
        else
          echo "exists=false" >> $GITHUB_OUTPUT
          echo "⚠️ fcctl-web not found - skipping VM execution tests (experimental code is gitignored)"
        fi

    - name: Run VM execution unit tests
      if: steps.check_fcctl_unit.outputs.exists == 'true'
      run: |
        cargo test -p terraphim_multi_agent vm_execution \
          --verbose \
          -- --nocapture

    - name: Run code extractor tests
      if: steps.check_fcctl_unit.outputs.exists == 'true'
      run: |
        cargo test -p terraphim_multi_agent code_extractor \
          --verbose \
          -- --nocapture

    - name: Skip message
      if: steps.check_fcctl_unit.outputs.exists == 'false'
      run: echo "✅ Skipping VM execution unit tests - experimental code not present"

  integration-tests:
    name: Integration Tests
    runs-on: [self-hosted, linux, x64]
    timeout-minutes: 15

    # NOTE: No services block - we check for existing Redis on self-hosted runner
    # and only start a container if none is available

    steps:
    - name: Check for existing Redis
      id: redis_check
      run: |
        if redis-cli -h 127.0.0.1 -p 6379 ping 2>/dev/null | grep -q PONG; then
          echo "Redis is available on localhost:6379"
          echo "redis_available=true" >> $GITHUB_OUTPUT
          echo "redis_host=127.0.0.1" >> $GITHUB_OUTPUT
          echo "redis_port=6379" >> $GITHUB_OUTPUT
          echo "redis_started=false" >> $GITHUB_OUTPUT
        else
          echo "No Redis found, will start container on port 6380"
          echo "redis_available=false" >> $GITHUB_OUTPUT
          echo "redis_host=127.0.0.1" >> $GITHUB_OUTPUT
          echo "redis_port=6380" >> $GITHUB_OUTPUT
          echo "redis_started=true" >> $GITHUB_OUTPUT
        fi

    - name: Start Redis container (if needed)
      if: steps.redis_check.outputs.redis_available == 'false'
      run: |
        docker run -d --name ci-redis-${{ github.run_id }} \
          -p 6380:6379 \
          --health-cmd "redis-cli ping" \
          --health-interval 10s \
          --health-timeout 5s \
          --health-retries 5 \
          redis:7-alpine
        # Wait for Redis to be healthy
        for i in {1..30}; do
          if redis-cli -h 127.0.0.1 -p 6380 ping 2>/dev/null | grep -q PONG; then
            echo "Redis container is ready"
            break
          fi
          echo "Waiting for Redis container... ($i/30)"
          sleep 2
        done

    - name: Checkout code
      uses: actions/checkout@v6

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@stable
      with:
        toolchain: stable

    - name: Install system dependencies
      run: |
        sudo apt-get update
        sudo apt-get install -y \
          build-essential \
          pkg-config \
          libssl-dev \
          curl

    - name: Cache cargo dependencies
      uses: actions/cache@v4
      with:
        path: |
          ~/.cargo/bin/
          ~/.cargo/registry/index/
          ~/.cargo/registry/cache/
          ~/.cargo/git/db/
          target/
        key: ${{ runner.os }}-cargo-integration-${{ hashFiles('**/Cargo.lock') }}
        restore-keys: |
          ${{ runner.os }}-cargo-integration-
          ${{ runner.os }}-cargo-

    - name: Check if fcctl-web exists
      id: check_fcctl
      run: |
        if [ -d "scratchpad/firecracker-rust/fcctl-web" ]; then
          echo "exists=true" >> $GITHUB_OUTPUT
        else
          echo "exists=false" >> $GITHUB_OUTPUT
          echo "⚠️ fcctl-web not found (experimental code is gitignored)"
        fi

    - name: Build fcctl-web
      if: steps.check_fcctl.outputs.exists == 'true'
      run: |
        cd scratchpad/firecracker-rust/fcctl-web
        cargo build --release

    - name: Start fcctl-web server
      if: steps.check_fcctl.outputs.exists == 'true'
      run: |
        cd scratchpad/firecracker-rust/fcctl-web
        ./target/release/fcctl-web &
        echo "FCCTL_WEB_PID=$!" >> $GITHUB_ENV

        # Wait for server to start
        for i in {1..30}; do
          if curl -s http://localhost:8080/health > /dev/null 2>&1; then
            echo "Server started successfully"
            break
          fi
          echo "Waiting for server to start... ($i/30)"
          sleep 2
        done

    - name: Run integration tests
      if: steps.check_fcctl.outputs.exists == 'true'
      env:
        REDIS_HOST: ${{ steps.redis_check.outputs.redis_host }}
        REDIS_PORT: ${{ steps.redis_check.outputs.redis_port }}
        REDIS_URL: redis://${{ steps.redis_check.outputs.redis_host }}:${{ steps.redis_check.outputs.redis_port }}
      run: |
        cd scratchpad/firecracker-rust/fcctl-web
        cargo test llm_api_tests \
          --verbose \
          -- --nocapture

    - name: Run HTTP API security tests
      if: steps.check_fcctl.outputs.exists == 'true'
      env:
        REDIS_HOST: ${{ steps.redis_check.outputs.redis_host }}
        REDIS_PORT: ${{ steps.redis_check.outputs.redis_port }}
        REDIS_URL: redis://${{ steps.redis_check.outputs.redis_host }}:${{ steps.redis_check.outputs.redis_port }}
      run: |
        cd scratchpad/firecracker-rust/fcctl-web
        cargo test security_tests \
          --verbose \
          -- --nocapture

    - name: Skip message
      if: steps.check_fcctl.outputs.exists == 'false'
      run: echo "✅ Skipping integration tests - fcctl-web experimental code not present (gitignored)"

    - name: Stop fcctl-web server
      if: always() && steps.check_fcctl.outputs.exists == 'true'
      run: |
        if [ -n "${FCCTL_WEB_PID:-}" ]; then
          kill $FCCTL_WEB_PID || true
        fi

    - name: Stop Redis container (if started)
      if: always() && steps.redis_check.outputs.redis_started == 'true'
      run: |
        docker stop ci-redis-${{ github.run_id }} || true
        docker rm ci-redis-${{ github.run_id }} || true

  websocket-tests:
    name: WebSocket Tests
    runs-on: [self-hosted, linux, x64]
    timeout-minutes: 10
    needs: integration-tests

    steps:
    - name: Checkout code
      uses: actions/checkout@v6

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@stable
      with:
        toolchain: stable

    - name: Cache cargo dependencies
      uses: actions/cache@v4
      with:
        path: |
          ~/.cargo/bin/
          ~/.cargo/registry/index/
          ~/.cargo/registry/cache/
          ~/.cargo/git/db/
          target/
        key: ${{ runner.os }}-cargo-websocket-${{ hashFiles('**/Cargo.lock') }}
        restore-keys: |
          ${{ runner.os }}-cargo-websocket-
          ${{ runner.os }}-cargo-

    - name: Check if fcctl-web exists
      id: check_fcctl_websocket
      run: |
        if [ -d "scratchpad/firecracker-rust/fcctl-web" ]; then
          echo "exists=true" >> $GITHUB_OUTPUT
        else
          echo "exists=false" >> $GITHUB_OUTPUT
          echo "⚠️ fcctl-web not found - skipping WebSocket tests (experimental code is gitignored)"
        fi

    - name: Build and start fcctl-web
      if: steps.check_fcctl_websocket.outputs.exists == 'true'
      run: |
        cd scratchpad/firecracker-rust/fcctl-web
        cargo build --release
        ./target/release/fcctl-web &
        echo "FCCTL_WEB_PID=$!" >> $GITHUB_ENV

        # Wait for server
        for i in {1..30}; do
          if curl -s http://localhost:8080/health > /dev/null 2>&1; then
            break
          fi
          sleep 2
        done

    - name: Run WebSocket tests
      if: steps.check_fcctl_websocket.outputs.exists == 'true'
      run: |
        cd scratchpad/firecracker-rust/fcctl-web
        cargo test websocket_tests \
          --verbose \
          --ignored \
          -- --nocapture

    - name: Skip message
      if: steps.check_fcctl_websocket.outputs.exists == 'false'
      run: echo "✅ Skipping WebSocket tests - fcctl-web experimental code not present (gitignored)"

    - name: Stop server
      if: always()
      run: |
        if [ -n "${FCCTL_WEB_PID:-}" ]; then
          kill $FCCTL_WEB_PID || true
        fi

  e2e-tests:
    name: End-to-End Tests
    runs-on: [self-hosted, linux, x64]
    timeout-minutes: 20
    needs: [unit-tests, integration-tests]

    steps:
    - name: Checkout code
      uses: actions/checkout@v6

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@stable
      with:
        toolchain: stable

    - name: Cache cargo dependencies
      uses: actions/cache@v4
      with:
        path: |
          ~/.cargo/bin/
          ~/.cargo/registry/index/
          ~/.cargo/registry/cache/
          ~/.cargo/git/db/
          target/
        key: ${{ runner.os }}-cargo-e2e-${{ hashFiles('**/Cargo.lock') }}
        restore-keys: |
          ${{ runner.os }}-cargo-e2e-
          ${{ runner.os }}-cargo-

    - name: Check if fcctl-web exists
      id: check_fcctl_e2e
      run: |
        if [ -d "scratchpad/firecracker-rust/fcctl-web" ]; then
          echo "exists=true" >> $GITHUB_OUTPUT
        else
          echo "exists=false" >> $GITHUB_OUTPUT
          echo "⚠️ fcctl-web not found - skipping E2E tests (experimental code is gitignored)"
        fi

    - name: Build all components
      if: steps.check_fcctl_e2e.outputs.exists == 'true'
      run: |
        cargo build --release
        cd scratchpad/firecracker-rust/fcctl-web
        cargo build --release
        cd -

    - name: Start fcctl-web server
      if: steps.check_fcctl_e2e.outputs.exists == 'true'
      run: |
        cd scratchpad/firecracker-rust/fcctl-web
        ./target/release/fcctl-web &
        echo "FCCTL_WEB_PID=$!" >> $GITHUB_ENV

        # Wait for server
        for i in {1..30}; do
          if curl -s http://localhost:8080/health > /dev/null 2>&1; then
            echo "Server ready for E2E tests"
            break
          fi
          sleep 2
        done

    - name: Run end-to-end tests
      if: steps.check_fcctl_e2e.outputs.exists == 'true'
      run: |
        cargo test agent_vm_integration_tests \
          --verbose \
          --ignored \
          -- --nocapture \
          --test-threads=1

    - name: Test agent configuration
      if: steps.check_fcctl_e2e.outputs.exists == 'true'
      run: |
        cargo test test_agent_with_vm_execution \
          --verbose \
          --ignored \
          -- --nocapture

    - name: Skip message
      if: steps.check_fcctl_e2e.outputs.exists == 'false'
      run: echo "✅ Skipping E2E tests - fcctl-web experimental code not present (gitignored)"

    - name: Stop server
      if: always()
      run: |
        if [ -n "${FCCTL_WEB_PID:-}" ]; then
          kill $FCCTL_WEB_PID || true
        fi

  security-tests:
    name: Security Tests
    runs-on: [self-hosted, linux, x64]
    timeout-minutes: 15

    steps:
    - name: Checkout code
      uses: actions/checkout@v6

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@stable
      with:
        toolchain: stable

    - name: Cache cargo dependencies
      uses: actions/cache@v4
      with:
        path: |
          ~/.cargo/bin/
          ~/.cargo/registry/index/
          ~/.cargo/registry/cache/
          ~/.cargo/git/db/
          target/
        key: ${{ runner.os }}-cargo-security-${{ hashFiles('**/Cargo.lock') }}
        restore-keys: |
          ${{ runner.os }}-cargo-security-
          ${{ runner.os }}-cargo-

    - name: Check if fcctl-web exists
      id: check_fcctl_security
      run: |
        if [ -d "scratchpad/firecracker-rust/fcctl-web" ]; then
          echo "exists=true" >> $GITHUB_OUTPUT
        else
          echo "exists=false" >> $GITHUB_OUTPUT
          echo "⚠️ fcctl-web not found - skipping VM security tests (experimental code is gitignored)"
        fi

    - name: Run dangerous pattern detection tests
      if: steps.check_fcctl_security.outputs.exists == 'true'
      run: |
        cargo test -p terraphim_multi_agent \
          test_dangerous_code_validation \
          test_code_injection_prevention \
          --verbose \
          -- --nocapture

    - name: Build fcctl-web for security tests
      if: steps.check_fcctl_security.outputs.exists == 'true'
      run: |
        cd scratchpad/firecracker-rust/fcctl-web
        cargo build --release
        ./target/release/fcctl-web &
        echo "FCCTL_WEB_PID=$!" >> $GITHUB_ENV

        # Wait for server
        for i in {1..30}; do
          if curl -s http://localhost:8080/health > /dev/null 2>&1; then
            break
          fi
          sleep 2
        done

    - name: Run security integration tests
      if: steps.check_fcctl_security.outputs.exists == 'true'
      run: |
        cd scratchpad/firecracker-rust/fcctl-web
        cargo test security_tests \
          --verbose \
          -- --nocapture

    - name: Test agent security handling
      if: steps.check_fcctl_security.outputs.exists == 'true'
      run: |
        cargo test test_agent_blocks_dangerous_code \
          --verbose \
          --ignored \
          -- --nocapture

    - name: Skip message
      if: steps.check_fcctl_security.outputs.exists == 'false'
      run: echo "✅ Skipping security tests - fcctl-web experimental code not present (gitignored)"

    - name: Stop server
      if: always() && steps.check_fcctl_security.outputs.exists == 'true'
      run: |
        if [ -n "${FCCTL_WEB_PID:-}" ]; then
          kill $FCCTL_WEB_PID || true
        fi

  performance-tests:
    name: Performance Tests
    runs-on: [self-hosted, linux, x64]
    timeout-minutes: 10

    steps:
    - name: Checkout code
      uses: actions/checkout@v6

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@stable
      with:
        toolchain: stable

    - name: Cache cargo dependencies
      uses: actions/cache@v4
      with:
        path: |
          ~/.cargo/bin/
          ~/.cargo/registry/index/
          ~/.cargo/registry/cache/
          ~/.cargo/git/db/
          target/
        key: ${{ runner.os }}-cargo-perf-${{ hashFiles('**/Cargo.lock') }}
        restore-keys: |
          ${{ runner.os }}-cargo-perf-
          ${{ runner.os }}-cargo-

    - name: Check if fcctl-web exists
      id: check_fcctl_perf
      run: |
        if [ -d "scratchpad/firecracker-rust/fcctl-web" ]; then
          echo "exists=true" >> $GITHUB_OUTPUT
        else
          echo "exists=false" >> $GITHUB_OUTPUT
          echo "⚠️ fcctl-web not found - skipping VM performance tests (experimental code is gitignored)"
        fi

    - name: Run unit performance tests
      if: steps.check_fcctl_perf.outputs.exists == 'true'
      run: |
        cargo test -p terraphim_multi_agent performance_tests \
          --release \
          --verbose \
          -- --nocapture

    - name: Build and start fcctl-web
      if: steps.check_fcctl_perf.outputs.exists == 'true'
      run: |
        cd scratchpad/firecracker-rust/fcctl-web
        cargo build --release
        ./target/release/fcctl-web &
        echo "FCCTL_WEB_PID=$!" >> $GITHUB_ENV

        # Wait for server
        for i in {1..30}; do
          if curl -s http://localhost:8080/health > /dev/null 2>&1; then
            break
          fi
          sleep 2
        done

    - name: Run WebSocket performance tests
      if: steps.check_fcctl_perf.outputs.exists == 'true'
      run: |
        cd scratchpad/firecracker-rust/fcctl-web
        cargo test websocket_performance_tests \
          --release \
          --ignored \
          --verbose \
          -- --nocapture

    - name: Run agent performance tests
      if: steps.check_fcctl_perf.outputs.exists == 'true'
      run: |
        cargo test agent_performance_tests \
          --release \
          --ignored \
          --verbose \
          -- --nocapture

    - name: Skip message
      if: steps.check_fcctl_perf.outputs.exists == 'false'
      run: echo "✅ Skipping performance tests - fcctl-web experimental code not present (gitignored)"

    - name: Stop server
      if: always() && steps.check_fcctl_perf.outputs.exists == 'true'
      run: |
        if [ -n "${FCCTL_WEB_PID:-}" ]; then
          kill $FCCTL_WEB_PID || true
        fi

  test-script:
    name: Test Runner Script
    runs-on: [self-hosted, linux, x64]
    timeout-minutes: 15

    steps:
    - name: Checkout code
      uses: actions/checkout@v6

    - name: Check if test script exists
      id: check_script
      run: |
        if [ -f "scripts/test-vm-execution.sh" ]; then
          echo "exists=true" >> $GITHUB_OUTPUT
        else
          echo "exists=false" >> $GITHUB_OUTPUT
          echo "⚠️ test-vm-execution.sh not found - skipping (experimental script)"
        fi

    - name: Make test script executable
      if: steps.check_script.outputs.exists == 'true'
      run: chmod +x scripts/test-vm-execution.sh

    - name: Test script help
      if: steps.check_script.outputs.exists == 'true'
      run: ./scripts/test-vm-execution.sh --help

    - name: Test script unit tests only
      if: steps.check_script.outputs.exists == 'true'
      run: |
        ./scripts/test-vm-execution.sh unit \
          --timeout 600 \
          --verbose

    - name: Verify script creates logs
      if: steps.check_script.outputs.exists == 'true'
      run: |
        test -d test-logs || echo "Log directory not created"
        find test-logs -name "*.log" | head -5

    - name: Skip message
      if: steps.check_script.outputs.exists == 'false'
      run: echo "✅ Skipping test script - experimental VM execution script not present"

  coverage:
    name: Test Coverage
    runs-on: [self-hosted, linux, x64]
    timeout-minutes: 30
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'

    steps:
    - name: Checkout code
      uses: actions/checkout@v6

    - name: Install Rust nightly
      uses: dtolnay/rust-toolchain@nightly
      with:
        components: rustfmt, clippy, llvm-tools-preview

    - name: Install grcov
      run: |
        curl -L https://github.com/mozilla/grcov/releases/latest/download/grcov-x86_64-unknown-linux-gnu.tar.bz2 | \
        tar jxf -
        sudo mv grcov /usr/local/bin/

    - name: Cache cargo dependencies
      uses: actions/cache@v4
      with:
        path: |
          ~/.cargo/bin/
          ~/.cargo/registry/index/
          ~/.cargo/registry/cache/
          ~/.cargo/git/db/
          target/
        key: ${{ runner.os }}-cargo-coverage-${{ hashFiles('**/Cargo.lock') }}
        restore-keys: |
          ${{ runner.os }}-cargo-coverage-
          ${{ runner.os }}-cargo-

    - name: Check if fcctl-web exists for coverage
      id: check_fcctl_coverage
      run: |
        if [ -d "scratchpad/firecracker-rust/fcctl-web" ]; then
          echo "exists=true" >> $GITHUB_OUTPUT
        else
          echo "exists=false" >> $GITHUB_OUTPUT
          echo "⚠️ fcctl-web not found - running coverage without integration tests (experimental code is gitignored)"
        fi

    - name: Run tests with coverage
      env:
        CARGO_INCREMENTAL: 0
        RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
        RUSTDOCFLAGS: "-Cpanic=abort"
      run: |
        # Unit tests
        cargo test -p terraphim_multi_agent vm_execution

        # Build fcctl-web and run integration tests if available
        if [ "${{ steps.check_fcctl_coverage.outputs.exists }}" == "true" ]; then
          # Build fcctl-web
          cd scratchpad/firecracker-rust/fcctl-web
          cargo build
          ./target/debug/fcctl-web &
          FCCTL_WEB_PID=$!
          cd -

          # Wait for server
          for i in {1..30}; do
            if curl -s http://localhost:8080/health > /dev/null 2>&1; then
              break
            fi
            sleep 2
          done

          # Integration tests (with mock data to avoid needing real VMs)
          cd scratchpad/firecracker-rust/fcctl-web
          cargo test llm_api_tests || true # Allow failure for coverage
          cd -

          # Stop server
          kill $FCCTL_WEB_PID || true
        else
          echo "Skipping fcctl-web integration tests for coverage - experimental code not present"
        fi

    - name: Generate coverage report
      run: |
        grcov . -s . --binary-path ./target/debug/ \
          -t html \
          --branch \
          --ignore-not-existing \
          --ignore "**/tests/**" \
          --ignore "**/test_*.rs" \
          --ignore "**/build.rs" \
          -o target/coverage/

    - name: Upload coverage to GitHub Pages
      uses: peaceiris/actions-gh-pages@v4
      if: github.ref == 'refs/heads/main'
      with:
        github_token: ${{ secrets.GITHUB_TOKEN }}
        publish_dir: ./target/coverage
        destination_dir: vm-execution-coverage

    - name: Upload coverage reports to Codecov
      uses: codecov/codecov-action@v5
      with:
        file: target/coverage/lcov.info
        flags: vm-execution
        name: vm-execution-coverage
        fail_ci_if_error: false

  summary:
    name: Test Summary
    runs-on: [self-hosted, linux, x64]
    needs: [unit-tests, integration-tests, websocket-tests, e2e-tests, security-tests, performance-tests]
    if: always()

    steps:
    - name: Test Results Summary
      run: |
        echo "## VM Execution Test Results" >> $GITHUB_STEP_SUMMARY
        echo "" >> $GITHUB_STEP_SUMMARY
        echo "| Test Suite | Status |" >> $GITHUB_STEP_SUMMARY
        echo "|------------|--------|" >> $GITHUB_STEP_SUMMARY
        echo "| Unit Tests | ${{ needs.unit-tests.result == 'success' && '✅ Passed' || '❌ Failed' }} |" >> $GITHUB_STEP_SUMMARY
        echo "| Integration Tests | ${{ needs.integration-tests.result == 'success' && '✅ Passed' || '❌ Failed' }} |" >> $GITHUB_STEP_SUMMARY
        echo "| WebSocket Tests | ${{ needs.websocket-tests.result == 'success' && '✅ Passed' || '❌ Failed' }} |" >> $GITHUB_STEP_SUMMARY
        echo "| End-to-End Tests | ${{ needs.e2e-tests.result == 'success' && '✅ Passed' || '❌ Failed' }} |" >> $GITHUB_STEP_SUMMARY
        echo "| Security Tests | ${{ needs.security-tests.result == 'success' && '✅ Passed' || '❌ Failed' }} |" >> $GITHUB_STEP_SUMMARY
        echo "| Performance Tests | ${{ needs.performance-tests.result == 'success' && '✅ Passed' || '❌ Failed' }} |" >> $GITHUB_STEP_SUMMARY
        echo "" >> $GITHUB_STEP_SUMMARY

        # Check if any tests failed
        if [[ "${{ needs.unit-tests.result }}" != "success" ]] || \
           [[ "${{ needs.integration-tests.result }}" != "success" ]] || \
           [[ "${{ needs.websocket-tests.result }}" != "success" ]] || \
           [[ "${{ needs.e2e-tests.result }}" != "success" ]] || \
           [[ "${{ needs.security-tests.result }}" != "success" ]] || \
           [[ "${{ needs.performance-tests.result }}" != "success" ]]; then
          echo "❌ **Some tests failed. Please check the logs above.**" >> $GITHUB_STEP_SUMMARY
          exit 1
        else
          echo "✅ **All VM execution tests passed!**" >> $GITHUB_STEP_SUMMARY
        fi