GitHub Actions
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 tiene una integración directa, cuando construyes URL de previsualización en scripts personalizados, o cuando quieres 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 el descubrimiento 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 de despliegue de previsualización del flujo de hosting.
- Token de omisión de previsualización protegida opcional.
- Número de pull request o SHA de commit para publicar la evidencia en GitHub.
Estrategia de rama y evento
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 toca 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 cablear 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 a 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 de plan e identificadores de plataforma de Autonomy guardados como secretos del repositorio.
- Un id de plan de test de Autonomy para el plan móvil que quieres ejecutar.
- Para iOS: un runner macOS que pueda construir la app de simulador.
- Para Android: un runner Linux con el SDK de Android para construir el APK.
iOS
Divide el job en dos etapas: build en macOS y luego disparar Autonomy en Linux. Pasa el .app entre ellas como artefacto de actions para no gastar minutos de macOS en una llamada de red.
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_URL=$(curl -fsS -X POST "$AUTONOMY_API_URL/api/artifacts/upload-url" \
-H "Authorization: Bearer $AUTONOMY_API_KEY" \
-H "Content-Type: application/json" | jq -r '.uploadUrl')
STORAGE_ID=$(curl -fsS -X POST "$UPLOAD_URL" \
-H "Content-Type: application/zip" \
--data-binary "@./build/MyApp.app.zip" | jq -r '.storageId')
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" \
'{
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 }
}')
curl -fsS -X POST "$AUTONOMY_API_URL/api/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 transferencia de artefactos.
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_URL=$(curl -fsS -X POST "$AUTONOMY_API_URL/api/artifacts/upload-url" \
-H "Authorization: Bearer $AUTONOMY_API_KEY" \
-H "Content-Type: application/json" | jq -r '.uploadUrl')
STORAGE_ID=$(curl -fsS -X POST "$UPLOAD_URL" \
-H "Content-Type: application/vnd.android.package-archive" \
--data-binary "@$APK_PATH" | jq -r '.storageId')
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" \
'{
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 }
}')
curl -fsS -X POST "$AUTONOMY_API_URL/api/trigger" \
-H "Authorization: Bearer $AUTONOMY_API_KEY" \
-H "Content-Type: application/json" \
-d "$TRIGGER_BODY"Usa un plan de test separado por plataforma para que los fallos apunten a la superficie correcta.
Solución de problemas
La ejecución web empieza 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 de PR
Confirma que el contexto de la pull request está disponible, que la app de GitHub de Autonomy está instalada para el repositorio y que el SHA del commit se pasó a Autonomy.
La subida de iOS se rechaza como build de 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 es un destino de simulador.
El build de Android no encuentra el SDK
Los runners de Ubuntu alojados por GitHub vienen con el SDK de Android preinstalado. Si te autoalojas, añade actions/setup-android (o instala las command-line tools) antes del paso de Gradle.
Las subidas móviles se acumulan
Usa targets explícitos para artefactos temporales de CI y entornos guardados para builds que deban reutilizarse.