GitHub Actions
Déclenchez Autonomy depuis GitHub Actions une fois qu'une cible de prévisualisation ou de préproduction est prête.
Utilisez GitHub Actions lorsque votre fournisseur de déploiement n'a pas d'intégration directe, lorsque vous construisez des URL de prévisualisation dans des scripts personnalisés, ou lorsque vous voulez qu'Autonomy s'exécute dans le cadre d'un pipeline CI existant.
Placement du workflow
Placez Autonomy après le build, le déploiement et la découverte de l'URL de prévisualisation. L'exécution doit recevoir l'URL finale qu'un relecteur ouvrirait. Gardez les filtres de branche explicites afin que les plans de longue durée ne s'exécutent pas à chaque push.
Secrets requis
Entrées du workflow
- Un projet Autonomy connecté au dépôt.
- L'URL de déploiement de prévisualisation issue du workflow d'hébergement.
- Jeton de contournement de prévisualisation protégée facultatif.
- Numéro de pull request ou SHA de commit pour publier les preuves dans GitHub.
Stratégie de branche et d'événement
Exécutez de courts plans de smoke sur les pull requests. Réservez les suites plus larges aux branches de version, aux exécutions planifiées ou au déclenchement manuel du workflow. Si le plan touche des services payants ou des données de test rares, rendez le déclencheur explicite.
Transfert d'artefact mobile
GitHub Actions est aussi la méthode recommandée pour câbler les exécutions mobiles lorsque le projet n'est pas sur Expo EAS. Le modèle est le même que pour les URL de prévisualisation web, mais l'entrée d'Autonomy est un artefact de build au lieu d'une URL : un .app simulateur pour iOS ou un .apk / .aab pour Android.
Entrées du workflow mobile
- Clé API, URL d'API, id de plan et identifiants de plateforme Autonomy stockés comme secrets du dépôt.
- Un identifiant de plan de test Autonomy pour le plan mobile que vous voulez exécuter.
- Pour iOS : un runner macOS capable de construire l'application simulateur.
- Pour Android : un runner Linux avec le SDK Android pour construire l'APK.
iOS
Divisez le job en deux étapes : build sur macOS, puis déclenchement d'Autonomy sur Linux. Transmettez le .app entre elles comme artefact d'actions afin de ne pas gaspiller de minutes macOS sur un appel réseau.
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
Les builds Android s'exécutent sur Linux, donc tout le workflow tient dans un seul job. Aucun transfert d'artefact n'est nécessaire.
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"Utilisez un plan de test distinct par plateforme afin que les échecs pointent vers la bonne surface.
Dépannage
L'exécution web démarre avant que la prévisualisation soit prête
Séparez le déploiement et le QA en jobs distincts et transmettez l'URL de déploiement via les sorties de job. Autonomy ne doit s'exécuter qu'une fois l'URL de prévisualisation connue.
Aucun commentaire de PR n'apparaît
Confirmez que le contexte de la pull request est disponible, que l'application GitHub Autonomy est installée pour le dépôt et que le SHA du commit a été transmis à Autonomy.
Le téléversement iOS est rejeté comme build pour appareil
L'étape de build macOS produit un .ipa au lieu d'un .app simulateur. Confirmez que -sdk iphonesimulator est sur la commande xcodebuild et que la destination est une destination simulateur.
Le build Android ne trouve pas le SDK
Les runners Ubuntu hébergés par GitHub sont livrés avec le SDK Android préinstallé. Si vous auto-hébergez, ajoutez actions/setup-android (ou installez les outils en ligne de commande) avant l'étape Gradle.
Les téléversements mobiles s'accumulent
Utilisez des targets explicites pour les artefacts CI temporaires et des environnements enregistrés pour les builds à réutiliser.