dev-docker-test.yml

name: Full Dev Docker Test

on:
  workflow_dispatch: {}
  push:
    branches:
      - v25
    paths-ignore:
      - CODE_OF_CONDUCT.md
      - LICENSE
      - README.md
      - readme/**
      - dockerfiles/**
      - Notebooks/**


jobs:
  build:
    runs-on: [self-hosted, Linux, ARM64]
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      # Set up Docker Buildx conditionally based on OS:
      - name: Set up Docker Buildx (Windows)
        if: runner.os == 'Windows'
        uses: docker/setup-buildx-action@v2

      - name: Set up Docker Buildx (Unix)
        if: runner.os != 'Windows'
        uses: docker/setup-buildx-action@v2
        with:
          driver: docker-container
          buildkitd-flags: --allow-insecure-entitlement security.insecure --allow-insecure-entitlement network.host

      - name: Log in to Docker Hub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      # Get Git Commit Hash for Linux/macOS
      - name: Get Git Commit Hash (Unix)
        if: runner.os != 'Windows'
        run: echo "GIT_HASH=$(git rev-parse --short=9 HEAD)" >> $GITHUB_ENV

      # Get Git Commit Hash for Windows using PowerShell
      - name: Get Git Commit Hash (Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $gitHash = (git rev-parse --short=9 HEAD).Trim()
          Add-Content -Path $env:GITHUB_ENV -Value "GIT_HASH=$gitHash"
      # Get Latest Release Tag for Linux/macOS
      - name: Get Latest Release Tag (Unix)
        if: runner.os != 'Windows'
        id: get_tag
        run: |
          TAG=$(curl -s https://api.github.com/repos/${{ github.repository }}/releases/latest | jq -r .tag_name)
          echo "RELEASE_TAG=$TAG" >> $GITHUB_ENV
      # Get Latest Release Tag for Windows using PowerShell
      - name: Get Latest Release Tag (Windows)
        if: runner.os == 'Windows'
        id: get_tag_win
        shell: powershell
        run: |
          $response = Invoke-WebRequest -Uri "https://api.github.com/repos/${{ github.repository }}/releases/latest" -UseBasicParsing
          $json = $response.Content | ConvertFrom-Json
          $tag = $json.tag_name
          Add-Content -Path $env:GITHUB_ENV -Value "RELEASE_TAG=$tag"
# Re-integrate once the other parts pass please Drew :)
      # Build and Push Dev_25 Docker Image for Unix using bash
      - name: Build and Push Dev_25 Docker Image (multi-arch, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          docker buildx build --platform linux/amd64,linux/arm64 \
            -t ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 \
            --push .

      # Build and Push Dev_v25 Docker Image for Windows using PowerShell
      - name: Build and Push Dev_25 Docker Image (multi-arch, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: docker buildx build --platform linux/amd64,linux/arm64 -t ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --push .








  test_help:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run Help command test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --help || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --help)
      - name: Run Help command test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --help
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --help
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f



  test_fairseq_single_eng:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English Fairseq headless single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq)
      - name: Run English Fairseq headless single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f




  test_fairseq_batch_eng:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English Fairseq headless batch test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine fairseq || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine fairseq)
      - name: Run English Fairseq headless batch test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine fairseq
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine fairseq
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f



  test_fairseq_custom_eng_single:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English Fairseq Custom-Voice headless single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav" || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav")
      - name: Run English Fairseq Custom-Voice headless single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f



  test_fairseq_custom_eng_batch:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English Fairseq Custom-Voice headless batch test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav" || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav")
      - name: Run English Fairseq Custom-Voice headless batch test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f



  test_unusual_fairseq_single:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run Unusual Fairseq headless single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq)
      - name: Run Unusual Fairseq headless single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f


  test_unusual_fairseq_batch:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run Unusual Fairseq headless batch test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebooks_dir "tools/workflow-testing" --tts_engine fairseq || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebooks_dir "tools/workflow-testing" --tts_engine fairseq)
      - name: Run Unusual Fairseq headless batch test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebooks_dir "tools/workflow-testing" --tts_engine fairseq
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebooks_dir "tools/workflow-testing" --tts_engine fairseq
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f


  test_unusual_fairseq_custom_single:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run Unusual Fairseq Custom-Voice headless single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav" || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav")
      - name: Run Unusual Fairseq Custom-Voice headless single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebook "tools/workflow-testing/test1.txt" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f


  test_unusual_fairseq_custom_batch:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run Unusual Fairseq Custom-Voice headless batch test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebooks_dir "tools/workflow-testing" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav" || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebooks_dir "tools/workflow-testing" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav")
      - name: Run Unusual Fairseq Custom-Voice headless batch test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebooks_dir "tools/workflow-testing" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language urd-script_devanagari --ebooks_dir "tools/workflow-testing" --tts_engine fairseq --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f


  test_vits_single:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English Vits headless single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine vits || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine vits)
      - name: Run English Vits headless single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine vits
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine vits
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f


  test_vits_batch:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English Vits headless batch test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine vits || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine vits)
      - name: Run English Vits headless batch test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine vits
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine vits
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f

  test_vits_custom_single:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English Vits Custom-Voice headless single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine vits --voice "voices/eng/elder/male/DavidAttenborough_24000.wav" || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine vits --voice "voices/eng/elder/male/DavidAttenborough_24000.wav")
      - name: Run English Vits Custom-Voice headless single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine vits --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine vits --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f



  test_vits_custom_batch:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English Vits Custom-Voice headless batch test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine vits --voice "voices/eng/elder/male/DavidAttenborough_24000.wav" || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine vits --voice "voices/eng/elder/male/DavidAttenborough_24000.wav")
      - name: Run English Vits Custom-Voice headless batch test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine vits --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine vits --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f

  test_yourtts_single:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English YourTTS headless single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine yourtts || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine yourtts)
      - name: Run English YourTTS headless single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine yourtts
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine yourtts
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f




  test_yourtts_batch:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English YourTTS headless batch test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine yourtts || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine yourtts)
      - name: Run English YourTTS headless batch test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine yourtts
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine yourtts
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f

  test_yourtts_custom_single:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English YourTTS Custom-Voice headless single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine yourtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav" || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine yourtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav")
      - name: Run English YourTTS Custom-Voice headless single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine yourtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine yourtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f



  test_yourtts_custom_batch:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English YourTTS Custom-Voice headless batch test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine yourtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav" || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine yourtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav")
      - name: Run English YourTTS Custom-Voice headless batch test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine yourtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine yourtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f

  test_default_headless_single:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run Default headless single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebook "tools/workflow-testing/test1.txt" || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebook "tools/workflow-testing/test1.txt")
      - name: Run Default headless single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebook "tools/workflow-testing/test1.txt"
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebook "tools/workflow-testing/test1.txt"
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f



  test_xtts_batch:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run Default XTTS headless batch test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebooks_dir "tools/workflow-testing" --tts_engine xtts || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebooks_dir "tools/workflow-testing" --tts_engine xtts)
      - name: Run Default XTTS headless batch test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebooks_dir "tools/workflow-testing" --tts_engine xtts
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebooks_dir "tools/workflow-testing" --tts_engine xtts
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f



  # The following tests are kept as comments for future implementation:
  # test_create_custom_xtts:
  #   needs: build
  #   runs-on: self-hosted
  #   steps:
  #     - name: Create the custom_xtts_test.zip for headless custom xtts model single test docker run ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev
  #       run: cp voices/eng/elder/male/DavidAttenborough_24000.wav ref.wav && zip -j custom_xtts_test.zip models/tts/tts_models--multilingual--multi-dataset--xtts_v2/config.json models/tts/tts_models--multilingual--multi-dataset--xtts_v2/model.pth models/tts/tts_models--multilingual--multi-dataset--xtts_v2/vocab.json ref.wav && rm -f ref.wav
  # test_xtts_custom_single:
  #   needs: build
  #   runs-on: self-hosted
  #   steps:
  #     - name: English xtts headless custom xtts model single test docker run ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev
  #       run: docker run ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine xtts --custom_model "custom_xtts_test.zip"
  # test_xtts_custom_batch:
  #   needs: build
  #   runs-on: self-hosted
  #   steps:
  #     - name: English xtts headless custom xtts model batch test docker run ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev
  #       run: docker run ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine xtts --custom_model "custom_xtts_test.zip"

  test_xtts_custom_single:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run Default XTTS headless Custom-Voice single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebook "tools/workflow-testing/test1.txt" --tts_engine xtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav" || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebook "tools/workflow-testing/test1.txt" --tts_engine xtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav")
      - name: Run Default XTTS headless Custom-Voice single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebook "tools/workflow-testing/test1.txt" --tts_engine xtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebook "tools/workflow-testing/test1.txt" --tts_engine xtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f

  test_xtts_custom_batch:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run Default XTTS headless Custom-Voice batch test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebooks_dir "tools/workflow-testing" --tts_engine xtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav" || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebooks_dir "tools/workflow-testing" --tts_engine xtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav")
      - name: Run Default XTTS headless Custom-Voice batch test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebooks_dir "tools/workflow-testing" --tts_engine xtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --ebooks_dir "tools/workflow-testing" --tts_engine xtts --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f



  test_xtts_finetuned_single:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English XTTS headless fine-tuned XTTS model single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine xtts --fine_tuned AiExplained || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine xtts --fine_tuned AiExplained)
      - name: Run English XTTS headless fine-tuned XTTS model single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine xtts --fine_tuned AiExplained
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine xtts --fine_tuned AiExplained
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f


  test_xtts_finetuned_single_long:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English XTTS headless fine-tuned XTTS model single long test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine xtts --fine_tuned AiExplained || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine xtts --fine_tuned AiExplained)
      - name: Run English XTTS headless fine-tuned XTTS model single long test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/long_test.txt" --tts_engine xtts --fine_tuned AiExplained
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/long_test.txt" --tts_engine xtts --fine_tuned AiExplained
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f


  test_xtts_finetuned_batch:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English XTTS headless fine-tuned XTTS model batch test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine xtts --fine_tuned AiExplained || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine xtts --fine_tuned AiExplained)
      - name: Run English XTTS headless fine-tuned XTTS model batch test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine xtts --fine_tuned AiExplained
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine xtts --fine_tuned AiExplained
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f



  test_bark_single:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English Bark headless single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine bark || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine bark)
      - name: Run English Bark headless single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine bark
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine bark
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f

# Batch Bark Test takes too long
#      - name: English Bark Custom-Voice headless batch test
#        run: docker run athomasson2/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine bark --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"


  test_bark_custom_single:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Prune all dangling Docker images
        run: docker image prune -f

      - name: Run English Bark Custom-Voice headless single test (with GPU if available, Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          echo "Attempting to run with GPU support..."
          docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine bark --voice "voices/eng/elder/male/DavidAttenborough_24000.wav" || \
          (echo "GPU run failed, trying without GPU support..." && docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine bark --voice "voices/eng/elder/male/DavidAttenborough_24000.wav")
      - name: Run English Bark Custom-Voice headless single test (with GPU if available, Windows)
        if: runner.os == 'Windows'
        shell: powershell
        run: |
          $ErrorActionPreference = "Stop"
          Write-Host "Attempting to run with GPU support..."
          try {
            docker run --rm --pull=always --gpus all ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine bark --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          } catch {
            Write-Host "GPU run failed, trying without GPU support..."
            docker run --rm --pull=always ${{ secrets.DOCKER_USERNAME }}/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebook "tools/workflow-testing/test1.txt" --tts_engine bark --voice "voices/eng/elder/male/DavidAttenborough_24000.wav"
          }
      - name: Prune all dangling Docker images
        run: docker image prune -f



# Batch Bark Test takes too long
#      - name: English Bark headless batch test
#        run: docker run athomasson2/ebook2audiobook:dev_v25 --headless --script_mode full_docker --language eng --ebooks_dir "tools/workflow-testing" --tts_engine bark