Expo EAS

Construisez des artefacts pour simulateur iOS et APK Android dans Expo EAS, transmettez-les à Autonomy et exécutez des parcours mobiles à chaque changement.

Expo EAS possède le pipeline de build pour les projets Expo. Utilisez cette intégration lorsque vous voulez qu'EAS produise le .app pour simulateur iOS ou l'.apk Android et qu'Autonomy exécute des parcours mobiles dessus au push, en pull request ou en déclenchement manuel.

Prérequis

Avant d'activer les exécutions EAS

Un projet Expo avec EAS déjà configuré pour iOS.
Un projet Autonomy lié au dépôt.
Au moins un test mobile qui réussit sur un téléversement manuel.
Un identifiant de plan de test Autonomy pour chaque plateforme que le workflow EAS doit déclencher.

Secrets requis

Stockez-les en tant que variables d'environnement EAS ou secrets sensibles. Ne les committez pas et ne les exposez pas via une variable EXPO_PUBLIC_* — Expo intègre celles-ci dans le bundle client.

Variable	Required	Description
AUTONOMY_API_KEY	Yes	Clé API Autonomy autorisée à téléverser des builds et à déclencher des exécutions.
AUTONOMY_API_URL	Yes	Origine de l'API Autonomy, par exemple https://api.autonomyqa.com ou l'URL de votre site Convex.
AUTONOMY_IOS_TEST_PLAN_ID	No	Plan de test à exécuter sur le build iOS téléversé. Requis si le workflow exécute iOS.
AUTONOMY_ANDROID_TEST_PLAN_ID	No	Plan de test à exécuter sur le build Android téléversé. Requis si le workflow exécute Android.
AUTONOMY_IOS_BUNDLE_ID	No	Bundle identifier iOS pour la cible de l'app simulateur.
AUTONOMY_ANDROID_PACKAGE_NAME	No	Nom de package Android pour la cible APK ou AAB.

Vous les trouverez dans le tableau de bord Autonomy :

Clé API : Profil → Clés API
URL d'API : paramètres du projet ou du déploiement
IDs de plans de test : onglet Tests → menu du plan → Copier l'ID. Utilisez un plan distinct par plateforme afin que les échecs pointent vers la bonne surface.

Profils de build

Ajoutez ou réutilisez des profils de build dans eas.json. Pour iOS, Autonomy a besoin d'un build .app pour simulateur, pas d'un .ipa signé. Le profil doit définir ios.simulator sur true. Pour Android, utilisez un profil de développement ou de distribution interne qui émet un APK.

eas.jsonjson

1{2  "build": {3    "autonomy-ios-simulator": {4      "distribution": "internal",5      "ios": {6        "simulator": true7      }8    },9    "autonomy-android-apk": {10      "distribution": "internal",11      "android": {12        "buildType": "apk"13      }14    }15  }16}

Workflow

Ajoutez .eas/workflows/autonomy-mobile-tests.yml. Le workflow construit chaque plateforme qui vous intéresse, télécharge l'artefact, le téléverse via l'API d'artefacts, l'analyse et déclenche le plan de test Autonomy correspondant.

L'exemple ci-dessous exécute les deux plateformes. Supprimez le job dont vous n'avez pas besoin si vous ne livrez qu'une seule plateforme.

.eas/workflows/autonomy-mobile-tests.ymlyaml

name: Autonomy Mobile Tests

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

jobs:
ios:
  name: Build and test iOS with Autonomy
  type: build
  params:
    platform: ios
    profile: autonomy-ios-simulator
  steps:
    - eas/checkout
    - eas/install_node_modules
    - eas/prebuild
    - eas/build
    - eas/download_build:
        id: download
        path: ./build
    - name: Upload to Autonomy and trigger plan
      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
        COMMIT_SHA="${EAS_BUILD_GIT_COMMIT_HASH:-}"
        APP_PATH=$(find ./build -name "*.app" -type d | head -n 1)
        test -n "$APP_PATH"
        APP_DIR=$(dirname "$APP_PATH")
        APP_NAME=$(basename "$APP_PATH")
        (cd "$APP_DIR" && zip -qr app.zip "$APP_NAME")
        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 "@$APP_DIR/app.zip" | jq -r '.storageId')
        curl -fsS -X POST "$AUTONOMY_API_URL/api/artifacts/scan" \
          -H "Authorization: Bearer $AUTONOMY_API_KEY" \
          -H "Content-Type: application/json" \
          -d "$(jq -n --arg storageId "$STORAGE_ID" '{ storageId: $storageId, platform: "ios", fileName: "app.zip", contentType: "application/zip" }')"
        curl -fsS -X POST "$AUTONOMY_API_URL/api/trigger" \
          -H "Authorization: Bearer $AUTONOMY_API_KEY" \
          -H "Content-Type: application/json" \
          -d "$(jq -n \
            --arg testPlanId "$AUTONOMY_TEST_PLAN_ID" \
            --arg storageId "$STORAGE_ID" \
            --arg bundleId "$AUTONOMY_IOS_BUNDLE_ID" \
            --arg commitSha "$COMMIT_SHA" \
            '{ testPlanId: $testPlanId, platforms: ["ios"], targets: { ios: { storageId: $storageId, sourceMode: "upload", bundleId: $bundleId, fileName: "app.zip" } }, deployment: { provider: "expo-eas", commitSha: $commitSha } }')"

android:
  name: Build and test Android with Autonomy
  type: build
  params:
    platform: android
    profile: autonomy-android-apk
  steps:
    - eas/checkout
    - eas/install_node_modules
    - eas/prebuild
    - eas/build
    - eas/download_build:
        id: download
        path: ./build
    - name: Upload to Autonomy and trigger plan
      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
        COMMIT_SHA="${EAS_BUILD_GIT_COMMIT_HASH:-}"
        APK_PATH=$(find ./build ( -name "*.apk" -o -name "*.aab" ) | head -n 1)
        test -n "$APK_PATH"
        FILE_NAME=$(basename "$APK_PATH")
        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/octet-stream" \
          --data-binary "@$APK_PATH" | jq -r '.storageId')
        curl -fsS -X POST "$AUTONOMY_API_URL/api/artifacts/scan" \
          -H "Authorization: Bearer $AUTONOMY_API_KEY" \
          -H "Content-Type: application/json" \
          -d "$(jq -n --arg storageId "$STORAGE_ID" --arg fileName "$FILE_NAME" '{ storageId: $storageId, platform: "android", fileName: $fileName, contentType: "application/octet-stream" }')"
        curl -fsS -X POST "$AUTONOMY_API_URL/api/trigger" \
          -H "Authorization: Bearer $AUTONOMY_API_KEY" \
          -H "Content-Type: application/json" \
          -d "$(jq -n \
            --arg testPlanId "$AUTONOMY_TEST_PLAN_ID" \
            --arg storageId "$STORAGE_ID" \
            --arg packageName "$AUTONOMY_ANDROID_PACKAGE_NAME" \
            --arg fileName "$FILE_NAME" \
            --arg commitSha "$COMMIT_SHA" \
            '{ testPlanId: $testPlanId, platforms: ["android"], targets: { android: { storageId: $storageId, sourceMode: "upload", packageName: $packageName, fileName: $fileName } }, deployment: { provider: "expo-eas", commitSha: $commitSha } }')"

Commentaires et checks GitHub

Transmettez le SHA du commit chaque fois que le contexte EAS ou GitHub en fournit un, afin qu'Autonomy puisse publier un check run sur le commit. Ne transmettez le numéro de PR que lorsque le workflow s'exécute pour une pull request. Le workflow ci-dessus protège les deux afin de rester valide au push, en PR et en déclenchement manuel.

Dépannage

Autonomy rejette le build iOS comme build pour appareil

Le profil EAS produit un .ipa signé au lieu d'un .app pour simulateur. Confirmez que ios.simulator est true sur le profil exécuté par le workflow.

EAS émet un AAB au lieu d'un APK

Pour le chemin d'installation le plus simple, le profil Android doit définir android.buildType sur apk. Autonomy accepte aussi .aab, mais l'APK est plus rapide à installer sur l'émulateur et évite les surprises de signature. Si vous devez livrer un AAB, assurez-vous que l'étape de téléversement sélectionne le fichier .aab.

Autonomy ne peut pas publier de commentaire de PR

L'application GitHub Autonomy doit être installée sur le dépôt et le workflow doit transmettre le SHA du commit. Sans cela, Autonomy n'a aucun point d'ancrage pour le commentaire.

Les téléversements s'accumulent dans le tableau de bord

Utilisez des targets explicites pour les artefacts EAS temporaires et des environnements enregistrés pour les builds à réutiliser. Réservez les téléversements du tableau de bord au build qu'un responsable de version choisit pour les exécutions de production.

Expo EAS

On this page