Dispara Autonomy desde GitHub Actions una vez que un objetivo de previsualización o staging esté listo.

Usa GitHub Actions cuando tu proveedor de despliegue no tenga una integración directa, cuando generes URL de previsualización en scripts personalizados o cuando quieras que Autonomy se ejecute como parte de un pipeline de CI existente.

Ubicación del flujo

Coloca Autonomy después del build, el despliegue y la obtención de la URL de previsualización. La ejecución debe recibir la URL final que abriría un revisor. Mantén explícitos los filtros de rama para que los planes de larga duración no se ejecuten en cada push.

Secretos requeridos

Entradas del flujo

Un proyecto de Autonomy conectado al repositorio.
La URL del despliegue de previsualización del flujo de hosting.
Token opcional para omitir la protección de la previsualización.
Número de pull request o SHA de commit para publicar la evidencia en GitHub.

Estrategia de ramas y eventos

Ejecuta planes de smoke cortos en las pull requests. Reserva las suites más amplias para las ramas de versión, las ejecuciones programadas o el disparo manual del flujo. Si el plan utiliza servicios de pago o datos de prueba escasos, haz explícito el disparador.

Transferencia de artefactos móviles

GitHub Actions también es la forma recomendada de configurar las ejecuciones móviles cuando el proyecto no está en Expo EAS. El patrón es el mismo que para las URL de previsualización web, pero la entrada de Autonomy es un artefacto de build en lugar de una URL: un .app de simulador para iOS o un .apk / .aab para Android.

Entradas del flujo móvil

Clave de API, URL de API, id del plan de test e identificadores de plataforma de Autonomy almacenados como secretos del repositorio.
Id del plan de test de Autonomy correspondiente al plan móvil que quieres ejecutar.
Para iOS: un runner de macOS que pueda construir la app de simulador.
Para Android: un runner de Linux con el SDK de Android para construir el APK.

iOS

Divide el job en dos etapas: haz el build en macOS y luego dispara Autonomy en Linux. Transfiere el .app entre ambas como un artefacto de actions para no gastar minutos de macOS en una llamada de red.

.github/workflows/ios-tests.ymlyaml

name: iOS Tests

on:
push:
  branches: [main]
pull_request:
workflow_dispatch:

jobs:
build:
  name: Build iOS Simulator app
  runs-on: macos-latest
  steps:
    - uses: actions/checkout@v5
    - name: Build .app
      shell: bash
      run: |
        set -euo pipefail
        xcodebuild \
          -workspace ios/MyApp.xcworkspace \
          -scheme MyApp \
          -configuration Release \
          -sdk iphonesimulator \
          -destination 'generic/platform=iOS Simulator' \
          -derivedDataPath ios/build \
          build
        mkdir -p .build
        cp -R ios/build/Build/Products/Release-iphonesimulator/MyApp.app .build/MyApp.app
    - uses: actions/upload-artifact@v5
      with:
        name: ios-simulator-app
        path: .build/MyApp.app
        retention-days: 1

test:
  name: Run Autonomy iOS plan
  needs: build
  runs-on: ubuntu-latest
  steps:
    - uses: actions/download-artifact@v5
      with:
        name: ios-simulator-app
        path: ./build/MyApp.app
    - name: Upload and trigger
      env:
        AUTONOMY_API_KEY: ${{ secrets.AUTONOMY_API_KEY }}
        AUTONOMY_API_URL: ${{ secrets.AUTONOMY_API_URL }}
        AUTONOMY_TEST_PLAN_ID: ${{ secrets.AUTONOMY_IOS_TEST_PLAN_ID }}
        AUTONOMY_IOS_BUNDLE_ID: ${{ secrets.AUTONOMY_IOS_BUNDLE_ID }}
      run: |
        set -euo pipefail
        (cd ./build && zip -qr MyApp.app.zip MyApp.app)
        UPLOAD_TARGET=$(curl -fsS -X POST "$AUTONOMY_API_URL/api/artifacts/upload-url" \
          -H "Authorization: Bearer $AUTONOMY_API_KEY" \
          -H "Content-Type: application/json" \
          -d '{"platform":"ios","fileName":"MyApp.app.zip"}')
        UPLOAD_URL=$(printf '%s' "$UPLOAD_TARGET" | jq -r '.uploadUrl')
        STORAGE_ID=$(printf '%s' "$UPLOAD_TARGET" | jq -r '.storageId')
        curl -fsS -X PUT "$UPLOAD_URL" \
          -H "Content-Type: application/zip" \
          --data-binary "@./build/MyApp.app.zip"
        SCAN_BODY=$(jq -n \
          --arg storageId "$STORAGE_ID" \
          '{ storageId: $storageId, platform: "ios", fileName: "MyApp.app.zip", contentType: "application/zip" }')
        curl -fsS -X POST "$AUTONOMY_API_URL/api/artifacts/scan" \
          -H "Authorization: Bearer $AUTONOMY_API_KEY" \
          -H "Content-Type: application/json" \
          -d "$SCAN_BODY"
        TRIGGER_BODY=$(jq -n \
          --arg testPlanId "$AUTONOMY_TEST_PLAN_ID" \
          --arg storageId "$STORAGE_ID" \
          --arg bundleId "$AUTONOMY_IOS_BUNDLE_ID" \
          --arg branch "$GITHUB_REF_NAME" \
          --arg commitSha "$GITHUB_SHA" \
          --arg idempotencyKey "github:${GITHUB_RUN_ID}:${GITHUB_RUN_ATTEMPT}:ios" \
          '{
            testPlanId: $testPlanId,
            platforms: ["ios"],
            branch: $branch,
            targets: { ios: { storageId: $storageId, sourceMode: "upload", bundleId: $bundleId, fileName: "MyApp.app.zip" } },
            deployment: { provider: "github-actions", branch: $branch, commitSha: $commitSha },
            idempotencyKey: $idempotencyKey
          }')
        curl -fsS -X POST "$AUTONOMY_API_URL/api/v1/run.trigger" \
          -H "Authorization: Bearer $AUTONOMY_API_KEY" \
          -H "Content-Type: application/json" \
          -d "$TRIGGER_BODY"

Android

Los builds de Android se ejecutan en Linux, así que todo el flujo cabe en un solo job. No se necesita transferir artefactos.

.github/workflows/android-tests.ymlyaml

name: Android Tests

on:
push:
  branches: [main]
pull_request:
workflow_dispatch:

jobs:
test:
  name: Build and run Autonomy Android plan
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v5
    - uses: actions/setup-java@v4
      with:
        distribution: temurin
        java-version: '17'
    - name: Build debug APK
      shell: bash
      run: |
        set -euo pipefail
        cd android
        ./gradlew assembleDebug
    - name: Upload and trigger
      env:
        AUTONOMY_API_KEY: ${{ secrets.AUTONOMY_API_KEY }}
        AUTONOMY_API_URL: ${{ secrets.AUTONOMY_API_URL }}
        AUTONOMY_TEST_PLAN_ID: ${{ secrets.AUTONOMY_ANDROID_TEST_PLAN_ID }}
        AUTONOMY_ANDROID_PACKAGE_NAME: ${{ secrets.AUTONOMY_ANDROID_PACKAGE_NAME }}
      run: |
        set -euo pipefail
        APK_PATH="android/app/build/outputs/apk/debug/app-debug.apk"
        UPLOAD_TARGET=$(curl -fsS -X POST "$AUTONOMY_API_URL/api/artifacts/upload-url" \
          -H "Authorization: Bearer $AUTONOMY_API_KEY" \
          -H "Content-Type: application/json" \
          -d '{"platform":"android","fileName":"app-debug.apk"}')
        UPLOAD_URL=$(printf '%s' "$UPLOAD_TARGET" | jq -r '.uploadUrl')
        STORAGE_ID=$(printf '%s' "$UPLOAD_TARGET" | jq -r '.storageId')
        curl -fsS -X PUT "$UPLOAD_URL" \
          -H "Content-Type: application/vnd.android.package-archive" \
          --data-binary "@$APK_PATH"
        SCAN_BODY=$(jq -n \
          --arg storageId "$STORAGE_ID" \
          '{ storageId: $storageId, platform: "android", fileName: "app-debug.apk", contentType: "application/vnd.android.package-archive" }')
        curl -fsS -X POST "$AUTONOMY_API_URL/api/artifacts/scan" \
          -H "Authorization: Bearer $AUTONOMY_API_KEY" \
          -H "Content-Type: application/json" \
          -d "$SCAN_BODY"
        TRIGGER_BODY=$(jq -n \
          --arg testPlanId "$AUTONOMY_TEST_PLAN_ID" \
          --arg storageId "$STORAGE_ID" \
          --arg packageName "$AUTONOMY_ANDROID_PACKAGE_NAME" \
          --arg branch "$GITHUB_REF_NAME" \
          --arg commitSha "$GITHUB_SHA" \
          --arg idempotencyKey "github:${GITHUB_RUN_ID}:${GITHUB_RUN_ATTEMPT}:android" \
          '{
            testPlanId: $testPlanId,
            platforms: ["android"],
            branch: $branch,
            targets: { android: { storageId: $storageId, sourceMode: "upload", packageName: $packageName, fileName: "app-debug.apk" } },
            deployment: { provider: "github-actions", branch: $branch, commitSha: $commitSha },
            idempotencyKey: $idempotencyKey
          }')
        curl -fsS -X POST "$AUTONOMY_API_URL/api/v1/run.trigger" \
          -H "Authorization: Bearer $AUTONOMY_API_KEY" \
          -H "Content-Type: application/json" \
          -d "$TRIGGER_BODY"

Usa un plan de test separado para cada plataforma, de modo que los fallos apunten a la superficie correcta. Si el artefacto ya está disponible en una URL HTTPS de corta duración, omite el paso de subida y pasa targets.ios.artifactUrl o targets.android.artifactUrl con sourceMode: "url".

Solución de problemas

La ejecución web comienza antes de que la previsualización esté lista

Separa el despliegue y el QA en jobs distintos y pasa la URL de despliegue mediante las salidas del job. Autonomy solo debe ejecutarse una vez que se conozca la URL de previsualización.

No aparece ningún comentario en la PR

Confirma que el contexto de la pull request esté disponible, que la app de GitHub de Autonomy esté instalada en el repositorio y que el SHA del commit se haya pasado a Autonomy.

La subida de iOS se rechaza por ser un build para dispositivo

El paso de build de macOS está produciendo un .ipa en lugar de un .app de simulador. Confirma que -sdk iphonesimulator esté en el comando xcodebuild y que el destino sea un destino de simulador.

El build de Android no encuentra el SDK

Los runners de Ubuntu alojados por GitHub incluyen el SDK de Android preinstalado. Si usas runners autoalojados, añade actions/setup-android (o instala las herramientas de línea de comandos) antes del paso de Gradle.

Las subidas móviles se acumulan

Usa objetivos de ejecución explícitos para los artefactos de CI de corta duración y entornos guardados para los builds que deban reutilizarse. Reserva las subidas desde el dashboard para los builds que un responsable de versiones seleccione para las ejecuciones de producción.

GitHub Actions

On this page