playwright-pages.yml

name: Playwright Report

on:
  workflow_dispatch:

concurrency:
  group: playwright-report-${{ github.ref }}
  cancel-in-progress: true

permissions:
  contents: read

jobs:
  playwright:
    name: Run Playwright Against Docker Dev Stack
    runs-on: ubuntu-latest
    timeout-minutes: 120
    outputs:
      test_outcome: ${{ steps.playwright.outcome }}

    steps:
      - name: Checkout
        uses: actions/checkout@v6
        with:
          fetch-depth: 0
          fetch-tags: true

      - name: Set up Node.js
        uses: actions/setup-node@v6
        with:
          node-version: 24
          cache: npm
          cache-dependency-path: tests/playwright/package-lock.json

      - name: Install Playwright dependencies
        working-directory: tests/playwright/
        run: npm ci

      - name: Install Chromium
        working-directory: tests/playwright/
        run: npx playwright install --with-deps chromium

      - name: Build and start FPP
        env:
          FPPBRANCH: ${{ github.ref_name }}
        run: docker compose -f Docker/docker-compose.playwright.yml up -d --build fpp

      - name: Wait for FPP web UI
        run: |
          for attempt in $(seq 1 60); do
            if curl -fsSI http://127.0.0.1:8080/ >/dev/null; then
              exit 0
            fi
            sleep 10
          done
          echo "FPP web UI did not become ready on http://127.0.0.1:8080"
          docker compose -f Docker/docker-compose.playwright.yml ps
          exit 1

      - name: Complete initial setup gate for CI
        run: |
          curl -fsS -X PUT \
            -H 'Content-Type: text/plain' \
            --data-binary '1' \
            http://127.0.0.1:8080/api/settings/initialSetup-02
          sleep 2

      - name: Wait for index.php to render
        run: |
          for attempt in $(seq 1 30); do
            body="$(curl -fsS http://127.0.0.1:8080/index.php || true)"
            if printf '%s' "${body}" | grep -q 'id="bodyWrapper"'; then
              if ! printf '%s' "${body}" | grep -q 'initialSetup.php?redirect='; then
                exit 0
              fi
            fi
            sleep 5
          done

          echo "index.php did not reach the expected ready state"
          echo "--- index.php response (first 200 lines) ---"
          curl -sS http://127.0.0.1:8080/index.php | sed -n '1,200p'
          echo "--- initialSetup.php response (first 120 lines) ---"
          curl -sS http://127.0.0.1:8080/initialSetup.php | sed -n '1,120p'
          exit 1

      - name: Browser preflight diagnostics
        working-directory: tests/playwright/
        env:
          PLAYWRIGHT_BASE_URL: http://127.0.0.1:8080
        run: |
          node <<'EOF'
          const { chromium } = require('@playwright/test');
          const fs = require('fs');

          (async () => {
            const browser = await chromium.launch({ headless: true });
            const page = await browser.newPage({ baseURL: process.env.PLAYWRIGHT_BASE_URL });

            const requests = [];
            page.on('requestfailed', request => {
              requests.push(`FAILED ${request.method()} ${request.url()} :: ${request.failure()?.errorText || 'unknown'}`);
            });
            page.on('response', response => {
              const status = response.status();
              if (status >= 400) {
                requests.push(`HTTP ${status} ${response.request().method()} ${response.url()}`);
              }
            });
            page.on('pageerror', error => {
              requests.push(`PAGEERROR ${error.message}`);
            });
            page.on('console', message => {
              if (message.type() === 'error') {
                requests.push(`CONSOLE ${message.type()} ${message.text()}`);
              }
            });

            await page.goto('/index.php', { waitUntil: 'domcontentloaded', timeout: 30000 });
            await page.waitForTimeout(3000);

            const html = await page.content();
            fs.writeFileSync('preflight-index.html', html);
            await page.screenshot({ path: 'preflight-index.png', fullPage: true });

            console.log(`FINAL_URL=${page.url()}`);
            console.log(`PAGE_TITLE=${await page.title()}`);
            console.log(`BODY_WRAPPER_COUNT=${await page.locator('#bodyWrapper').count()}`);
            console.log(`INITIAL_SETUP_COUNT=${await page.locator('#initialSetup').count()}`);
            console.log('--- PRELIGHT EVENTS ---');
            for (const line of requests) {
              console.log(line);
            }

            await browser.close();
          })().catch(error => {
            console.error(error);
            process.exit(1);
          });
          EOF

      - name: Run Playwright tests
        id: playwright
        continue-on-error: true
        working-directory: tests/playwright/
        env:
          PLAYWRIGHT_BASE_URL: http://127.0.0.1:8080
        run: npm test

      - name: Upload Playwright debug artifacts
        if: always()
        uses: actions/upload-artifact@v7
        with:
          name: playwright-debug
          path: |
            tests/playwright/preflight-index.html
            tests/playwright/preflight-index.png
            tests/playwright/test-results
          if-no-files-found: warn
          retention-days: 14

      - name: Upload Playwright report artifact
        if: always()
        uses: actions/upload-artifact@v7
        with:
          name: playwright-report
          path: tests/playwright/playwright-report
          if-no-files-found: error
          retention-days: 14

      - name: Show Docker logs on failure
        if: always()
        run: docker compose -f Docker/docker-compose.playwright.yml logs --no-color fpp

      - name: Stop Docker stack
        if: always()
        run: docker compose -f Docker/docker-compose.playwright.yml down --volumes

  deploy:
    name: Publish Report To GitHub Pages
    needs: playwright
    if: always() && needs.playwright.result != 'cancelled'
    runs-on: ubuntu-latest
    permissions:
      pages: write
      id-token: write

    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}

    steps:
      - name: Configure GitHub Pages
        uses: actions/configure-pages@v6

      - name: Download Playwright report artifact
        uses: actions/download-artifact@v8
        with:
          name: playwright-report
          path: tests/playwright/playwright-report

      - name: Upload Pages artifact
        uses: actions/upload-pages-artifact@v5
        with:
          path: tests/playwright/playwright-report

      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v5

  finalize:
    name: Finalize Workflow Status
    needs:
      - playwright
      - deploy
    if: always()
    runs-on: ubuntu-latest

    steps:
      - name: Fail workflow if tests failed
        run: |
          if [ "${{ needs.playwright.outputs.test_outcome }}" != "success" ]; then
            echo "Playwright tests failed. Report was still deployed to GitHub Pages."
            exit 1
          fi

      - name: Print Github Pages URL
        run: |
          echo "https://${{ github.repository_owner }}.github.io/${{ github.event.repository.name }}"