Déclenchez Autonomy depuis GitHub Actions une fois qu'une cible de prévisualisation ou de préproduction prête.

Utilisez GitHub Actions lorsque votre fournisseur de déploiement ne dispose pas d'une intégration directe, lorsque vous créez des URL de prévisualisation dans des scripts personnalisés ou lorsque vous souhaitez 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. Définissez explicitement les filtres de branche 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.
Un jeton facultatif de contournement de la prévisualisation protégée.
Le numéro de pull request ou le SHA du commit pour publier les preuves dans GitHub.

Stratégie de branche et d'événement

Exécutez de courts plans de smoke test sur les pull requests. Réservez les suites plus étendues aux branches de version, aux exécutions planifiées ou au déclenchement manuel du workflow. Si le plan utilise des services payants ou des données de test rares, rendez le déclencheur explicite.

Transfert d'artefact mobile

GitHub Actions est également la méthode recommandée pour configurer les exécutions mobiles lorsque le projet n'utilise pas 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 plutôt qu'une URL : un .app de simulateur pour iOS ou un .apk / .aab pour Android.

Entrées du workflow mobile

La clé API Autonomy, l'URL de l'API, l'identifiant du plan de test et les identifiants de plateforme stockés comme secrets du dépôt.
L'identifiant du plan de test Autonomy correspondant au plan mobile que vous souhaitez exécuter.
Pour iOS : un runner macOS capable de construire l'application pour simulateur.
Pour Android : un runner Linux avec le SDK Android pour construire l'APK.

iOS

Divisez le job en deux étapes : effectuez le build sur macOS, puis déclenchez Autonomy sur Linux. Transmettez le .app de l'une à l'autre comme artefact Actions afin de ne pas consommer des minutes macOS pour un appel réseau.

.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

Les builds Android s'exécutent sur Linux, l'ensemble du workflow tient donc dans un seul job. Aucun transfert d'artefact n'est nécessaire.

.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"

Utilisez un plan de test distinct pour chaque plateforme afin que les échecs indiquent la bonne surface. Si l'artefact est déjà disponible à une URL HTTPS à courte durée de vie, ignorez l'étape de téléversement et transmettez targets.ios.artifactUrl ou targets.android.artifactUrl avec sourceMode: "url".

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 par l'intermédiaire des 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

Vérifiez 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 pour simulateur. Vérifiez que -sdk iphonesimulator figure dans la commande xcodebuild et que la destination est une destination de simulateur.

Le build Android ne parvient pas à trouver le SDK

Les runners Ubuntu hébergés par GitHub sont fournis avec le SDK Android préinstallé. Si vous utilisez votre propre hébergement, 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 cibles d'exécution explicites pour les artefacts CI à courte durée de vie et des environnements enregistrés pour les builds qui doivent être réutilisés. Réservez les téléversements depuis le tableau de bord aux builds qu'un responsable de livraison sélectionne pour les exécutions en production.

Automation notes

Lorsque vous ajoutez Autonomy à un workflow CI existant, conservez les jobs, les filtres de branche, les étapes de déploiement et les secrets existants. Pour les exécutions web, n'ajoutez Autonomy qu'une fois l'URL de prévisualisation connue. Pour les exécutions iOS, construisez le .app sur macOS et déclenchez Autonomy sur Linux afin d'éviter de consommer des minutes macOS pour un appel réseau. Pour les exécutions Android, l'ensemble du flux tient dans un seul job Linux. Lisez AUTONOMY_API_KEY, AUTONOMY_API_URL, les identifiants de plan de test propres aux plateformes, les identifiants de bundle et les noms de package uniquement depuis secrets.* ; ne les codez jamais en dur. Générez uniquement le fichier de workflow correspondant à la plateforme réellement livrée par le projet.

GitHub Actions

On this page