Autonomy dokumentatsioon
Integratsioonid

CircleCI

Käivita Autonomy CircleCI-st veebi eelvaate-URL-i või mobiili build'iga ja luba torul jätkuda ainult eduka tulemuse korral.

Kasuta CircleCI-d Autonomy käivituste järjekorda lisamiseks pärast juurutust või mobiili build'i. See leht sisaldab API skripti, täielikke konfiguratsioone ja tulemuse kontrolli.

Töövoo paigutus

Käivita Autonomy siis, kui eelvaade on kättesaadav või mobiili artefakt olemas. Iga konfiguratsioon on täielik alternatiiv failile .circleci/config.yml; kopeeri oma platvormile sobiv. Olemasolevas töövoos säilita juurutustöö ning määra see Autonomy töö sõltuvuseks võtmega requires. Edasta juurutuse lõplik URL, mitte CI konteineri localhost.

Nõutavad saladused

Ava CircleCI-s Project Settings → Environment Variables ja lisa järgmised sisendid. CircleCI lisab need töö käsukeskkonda; ära kirjuta API võtit YAML-i. Neid võib hoida ka piiratud kontekstis: määra context töö kirjele jaotises workflows, mitte jaotises jobs.

  • AUTONOMY_API_URL: Autonomy API baas-URL ilma /api osata; kasuta Convexi HTTP URL-i lõpuga .convex.site.
  • AUTONOMY_API_KEY: aut_ organisatsiooni API võti plaaniga samast juurutusest ja organisatsioonist.
  • AUTONOMY_TEST_PLAN_ID: ava olemasolev plaan vaates Test Plans ja kopeeri selle ID töölaua URL-i osast /test-plans/<id>. Plaan peab sisaldama vähemalt üht valitud platvormi testjuhtumit. See on plaani ID, mitte üksiku testjuhtumi ID.
  • Veeb: PREVIEW_URL, kättesaadav juurutuse HTTPS-URL.
  • Mobiil: APP_IDENTIFIER, artefaktile vastav iOS-i bundle ID või Androidi paketinimi.
  • Testjuhtumid, mida saab käivitada nende selgesõnaliste sihtmärkidega, ilma üksnes salvestatud Environment'ist saadavate käitusväärtuste või pääsuandmeteta. Valitud platvormi jaoks peab olema saadaval runner.

Kasuta iga platvormi jaoks eraldi plaani. Konfiguratsioonid eeldavad, et AUTONOMY_TEST_PLAN_ID ja APP_IDENTIFIER vastavad valitud retseptile. Platvormide ühendamisel edasta õiged väärtused eraldi kontekstide või platvormipõhiste muutujatega. Juhtumite rühmitamist kirjeldab Testiplaanid.

Veebi eelvaate-URL

Loo hoidlasse .ci/, salvesta järgmine plokk failina .ci/autonomy.sh ja lisa see versioonihaldusse koos failiga .circleci/config.yml. Tööd käivitavad selle Bashiga, seega ei vaja fail käivitusõigust. Skript vajab Bashi, curli ja jq-d, mis on allolevates Linuxi tõmmistes olemas.

#!/usr/bin/env bash
set -euo pipefail
set +x
: "${AUTONOMY_API_URL:?Set the API base URL, without /api}"
: "${AUTONOMY_API_KEY:?Set an aut_ organization API key}"
: "${AUTONOMY_TEST_PLAN_ID:?Set the Test Plans ID for this platform}"
: "${AUTONOMY_REQUEST_ID:?Set a unique CI job/attempt ID}"
platform="${1:-web}"
api="${AUTONOMY_API_URL%/}"
work=$(mktemp -d)
trap 'rm -rf "$work"' EXIT

post() {
  curl --fail-with-body --silent --show-error \
    --connect-timeout 15 --max-time 90 \
    -X POST "$api$1" \
    -H "Authorization: Bearer $AUTONOMY_API_KEY" \
    -H 'Content-Type: application/json' --data-binary "$2"
}

case "$platform" in
  web)
    : "${PREVIEW_URL:?Set the reachable preview URL after deployment}"
    targets=$(jq -n --arg url "$PREVIEW_URL" '{web:{baseUrl:$url}}')
    ;;
  ios|android)
    : "${ARTIFACT_PATH:?Set the path to the app archive or APK}"
    : "${APP_IDENTIFIER:?Set the bundle ID or Android package name}"
    test -s "$ARTIFACT_PATH"
    file=$(basename "$ARTIFACT_PATH")
    bytes=$(wc -c < "$ARTIFACT_PATH" | tr -d '[:space:]')
    content_type=application/zip
    if [ "$platform" = android ]; then
      content_type=application/vnd.android.package-archive
    fi
    upload=$(post /api/artifacts/upload-url "$(jq -n \
      --arg platform "$platform" --arg fileName "$file" \
      --arg contentType "$content_type" --argjson declaredBytes "$bytes" \
      '{platform:$platform,fileName:$fileName,contentType:$contentType,declaredBytes:$declaredBytes}')")
    url=$(jq -er '.uploadUrl | strings | select(length > 0)' <<< "$upload")
    storage=$(jq -er '.storageId | strings | select(length > 0)' <<< "$upload")
    intent=$(jq -er '.intentId | strings | select(length > 0)' <<< "$upload")
    jq -e '.method == "PUT"' <<< "$upload" > /dev/null
    curl --fail-with-body --silent --show-error \
      --connect-timeout 15 --max-time 600 -X PUT "$url" \
      -H "Content-Type: $content_type" --data-binary "@$ARTIFACT_PATH"
    scan=$(post /api/artifacts/scan "$(jq -n \
      --arg storageId "$storage" --arg intentId "$intent" \
      '{storageId:$storageId,intentId:$intentId}')")
    if ! jq -e '.status == "clean"' <<< "$scan" > /dev/null; then
      echo 'Artifact scan did not pass; refusing to trigger.' >&2
      exit 1
    fi
    targets=$(jq -n --arg platform "$platform" --arg storageId "$storage" \
      --arg fileName "$file" --arg identifier "$APP_IDENTIFIER" \
      '{($platform):({storageId:$storageId,sourceMode:"upload",fileName:$fileName} +
        (if $platform == "ios" then {bundleId:$identifier} else {packageName:$identifier} end))}')
    ;;
  *) echo 'Usage: bash .ci/autonomy.sh web|ios|android' >&2; exit 2 ;;
esac

body=$(jq -n --arg testPlanId "$AUTONOMY_TEST_PLAN_ID" \
  --arg platform "$platform" --argjson targets "$targets" \
  --arg branch "${AUTONOMY_BRANCH:-manual}" \
  --arg commitSha "${AUTONOMY_COMMIT_SHA:-}" \
  --arg key "$AUTONOMY_REQUEST_ID:$platform" \
  '{testPlanId:$testPlanId,platforms:[$platform],targets:$targets,
    branch:$branch,deployment:{branch:$branch,commitSha:$commitSha},idempotencyKey:$key}')
post /api/v1/run.trigger "$body" > "$work/trigger.json"
jq -e '.runIds | type == "array" and length > 0' "$work/trigger.json" > /dev/null
jq -er '.runIds[] | strings | select(length > 0)' "$work/trigger.json" > "$work/run-ids"
printf 'Queued Autonomy runs:\n'
cat "$work/run-ids"

deadline=$((SECONDS + ${AUTONOMY_WAIT_SECONDS:-1200}))
while IFS= read -r run_id; do
  while :; do
    if (( SECONDS >= deadline )); then
      echo "Timed out waiting for $run_id; failing the CI job." >&2
      exit 1
    fi
    result=$(post /api/v1/run.get "$(jq -n --arg runId "$run_id" '{runId:$runId}')")
    status=$(jq -er '.status' <<< "$result")
    case "$status" in
      queued|running|retrying) sleep 10 ;;
      passing|failed|unverified|invalid|canceled)
        printf '%s: %s\n' "$run_id" "$status"
        if ! jq -e '.verdict == "passed" and .validity == "valid"' <<< "$result" > /dev/null; then
          echo "Autonomy gate failed for $run_id." >&2
          exit 1
        fi
        break ;;
      *) echo "Unexpected run status: $status" >&2; exit 1 ;;
    esac
  done
done < "$work/run-ids"
echo 'Every Autonomy run passed.'

Salvesta konfiguratsioon failina .circleci/config.yml. Esimeseks käivituseks määra PREVIEW_URL juba juurutatud eelvaatele ja lükka failid harusse staging. Enne Autonomy käivitamist peab HTTP kontroll õnnestuma.

Commit'ipõhise eelvaate korral ekspordi PREVIEW_URL ja käivita skript samas run-sammus. Tavaline export ei säili järgmises sammus. Sama töö hilisema run-sammu kasutamiseks lisa see rida juurutussammu pärast URL-i leidmist; CircleCI laadib BASH_ENV faili järgmistes sammudes:

printf 'export PREVIEW_URL=%q\n' "$PREVIEW_URL" >> "$BASH_ENV"

Eraldi tööde korral salvesta leitud URL ühele reale faili /tmp/autonomy-preview/preview-url.txt. Kasuta juurutustöös persist_to_workspace võtmetega root: /tmp/autonomy-preview ja paths: [preview-url.txt]. Autonomy töös kasuta attach_workspace võtmega at: /tmp/autonomy-preview, seejärel käivita enne HTTP kontrolli export PREVIEW_URL="$(cat /tmp/autonomy-preview/preview-url.txt)". BASH_ENV ei edasta väärtusi tööde vahel.

version: 2.1

jobs:
  autonomy-web:
    docker:
      - image: cimg/base:current
    steps:
      - checkout
      - run:
          name: Check preview and run Autonomy
          no_output_timeout: 30m
          command: |
            set -euo pipefail
            set +x
            : "${PREVIEW_URL:?Set the deployed preview URL}"
            curl --fail --silent --show-error --location \
              --connect-timeout 15 --max-time 30 \
              --retry 10 --retry-delay 3 --retry-all-errors \
              --output /dev/null "$PREVIEW_URL"
            export AUTONOMY_BRANCH="${CIRCLE_BRANCH:-local}"
            export AUTONOMY_COMMIT_SHA="${CIRCLE_SHA1:-$(git rev-parse HEAD)}"
            export AUTONOMY_REQUEST_ID="circleci:${CIRCLE_WORKFLOW_ID:-local}:${CIRCLE_BUILD_NUM:-$(date +%s)-$$}:web"
            bash .ci/autonomy.sh web

workflows:
  preview-qa:
    jobs:
      - autonomy-web:
          filters:
            branches:
              only: staging

Kohalikuks kontrolliks macOS-il või Linuxil käivita Docker ja laadi alla ametlik varasem CLI versioon v0.1.47860. Vali oma süsteemile (darwin macOS-i, linux Linuxi jaoks) ja protsessorile (arm64 Apple siliconi või ARM-i, amd64 Inteli või AMD jaoks) vastav .tar.gz arhiiv. Paki see lahti ja aseta käivitatav fail circleci-v0 oma PATH-is olevasse kausta. Praegusest CLI v1-st eemaldati kohalik käivitus; allolevad käsud kasutavad seetõttu varasemat binaarfaili.

Ekspordi neli sisendit kohalikus käsukeskkonnas ning käivita need käsud commit'itud failidega hoidlast. CircleCI ei impordi kohalikult projekti saladusi ega kontekste; iga -e on vajalik. Versiooni 2.1 konfiguratsioon tuleb enne käivitamist töödelda.

circleci-v0 config validate .circleci/config.yml
circleci-v0 config process .circleci/config.yml > /tmp/autonomy-circleci.yml
circleci-v0 local execute -c /tmp/autonomy-circleci.yml \
  -e "AUTONOMY_API_URL=$AUTONOMY_API_URL" \
  -e "AUTONOMY_API_KEY=$AUTONOMY_API_KEY" \
  -e "AUTONOMY_TEST_PLAN_ID=$AUTONOMY_TEST_PLAN_ID" \
  -e "PREVIEW_URL=$PREVIEW_URL" \
  -e "AUTONOMY_WAIT_SECONDS=${AUTONOMY_WAIT_SECONDS:-1200}" \
  autonomy-web

Kohalik käivitus käivitab ainult selle Dockeri töö. See ei tõenda töövoo ajastamist, kontekstipiiranguid, macOS-i käivitust ega iOS-i workspace'i üleandmist.

Mobiili artefakti üleandmine

Skript küsib üleslaadimis-URL-i koos faili suurusega, laadib faili üles PUT-iga ja skannib nii storageId kui ka intentId abil. Käivitus algab alles pärast skannimise tulemust clean. Säilita ülaltoodud .ci/autonomy.sh ja asenda .circleci/config.yml sobiva konfiguratsiooniga.

iOS

Ehita simulaatori .app macOS-il ning paki see enne ülekannet arhiivi, et säilitada käivitusõigused ja sümboolsed lingid. Edasta ZIP Linuxi tööle võtmetega persist_to_workspace ja attach_workspace. Üleslaadimine ja ootamine kasutavad Linuxi krediite.

Näide eeldab natiivset Xcode'i projekti asukohas ios/MyApp.xcodeproj, jagatud skeemi MyApp ja toodet MyApp.app. Asenda nimed oma projekti omadega. Kui rakendus kasutab Xcode'i workspace'i, asenda -project võtmega -workspace ning õige teega; säilita olemasolevad sõltuvuste paigaldamise sammud enne xcodebuild käsku. Ära laadi üles seadmele mõeldud .ipa faili.

CircleCI dokumenteerib praegu versiooni 27.0.0 ressursiklassil m4pro.medium. macOS on saadaval Free paketis selle krediidipiiri ulatuses; kontrolli enne build'ide käivitamist jääki. circleci-v0 local execute ei saa seda macOS-i tööd käivitada.

version: 2.1

jobs:
  build-ios:
    macos:
      xcode: "27.0.0"
    resource_class: m4pro.medium
    steps:
      - checkout
      - run:
          name: Build and archive the Simulator app
          command: |
            set -euo pipefail
            xcodebuild \
              -project ios/MyApp.xcodeproj \
              -scheme MyApp \
              -configuration Release \
              -sdk iphonesimulator \
              -destination 'generic/platform=iOS Simulator' \
              -derivedDataPath ios/build \
              CODE_SIGNING_ALLOWED=NO build
            mkdir -p /tmp/autonomy-ios
            (cd ios/build/Build/Products/Release-iphonesimulator && \
              zip -qry /tmp/autonomy-ios/MyApp.app.zip MyApp.app)
      - persist_to_workspace:
          root: /tmp/autonomy-ios
          paths:
            - MyApp.app.zip

  autonomy-ios:
    docker:
      - image: cimg/base:current
    steps:
      - checkout
      - attach_workspace:
          at: /tmp/autonomy-ios
      - run:
          name: Upload and run Autonomy
          no_output_timeout: 30m
          command: |
            set -euo pipefail
            set +x
            export ARTIFACT_PATH=/tmp/autonomy-ios/MyApp.app.zip
            export AUTONOMY_BRANCH="$CIRCLE_BRANCH"
            export AUTONOMY_COMMIT_SHA="$CIRCLE_SHA1"
            export AUTONOMY_REQUEST_ID="circleci:$CIRCLE_WORKFLOW_ID:$CIRCLE_BUILD_NUM:ios"
            bash .ci/autonomy.sh ios

workflows:
  ios-qa:
    jobs:
      - build-ios:
          filters:
            branches:
              only: staging
      - autonomy-ios:
          requires:
            - build-ios
          filters:
            branches:
              only: staging

Android

Linuxi Androidi tõmmis sisaldab SDK-d, Javat, curli ja jq-d. Näide eeldab natiivset Gradle'i projekti kaustas android/, versioonihaldusse lisatud käivitatavat gradlew faili ning mooduli app silumis-APK-d. Kohanda Gradle'i ülesanne ja APK tee oma mooduli või variandi järgi. Säilita sõltuvuste ettevalmistus, kui rakendus vajab ka JavaScripti või muid build'i tööriistu.

version: 2.1

jobs:
  autonomy-android:
    docker:
      - image: cimg/android:2026.08
    resource_class: medium
    steps:
      - checkout
      - run:
          name: Build the debug APK
          command: |
            set -euo pipefail
            cd android
            ./gradlew --no-daemon :app:assembleDebug
      - run:
          name: Upload and run Autonomy
          no_output_timeout: 30m
          command: |
            set -euo pipefail
            set +x
            export ARTIFACT_PATH=android/app/build/outputs/apk/debug/app-debug.apk
            export AUTONOMY_BRANCH="$CIRCLE_BRANCH"
            export AUTONOMY_COMMIT_SHA="$CIRCLE_SHA1"
            export AUTONOMY_REQUEST_ID="circleci:$CIRCLE_WORKFLOW_ID:$CIRCLE_BUILD_NUM:android"
            bash .ci/autonomy.sh android

workflows:
  android-qa:
    jobs:
      - autonomy-android:
          filters:
            branches:
              only: staging

Töövoo jätkamise sidumine tulemusega

Järjekorda lisatud käivitus ei tähenda läbitud testi. Skript väljastab kõik tagastatud käivituste ID-d ja küsib olekut POST /api/v1/run.get kaudu. See õnnestub ainult siis, kui iga käivitus tagastab verdict: "passed" ja validity: "valid"; tõrked, tühistamised, kehtetud või kontrollimata käivitused, API vead ja ajalimiidi ületamine lõpetavad töö ebaõnnestumisega.

Ooteaeg on kogu plaani peale 1200 sekundit. Pikema plaani jaoks määra AUTONOMY_WAIT_SECONDS ja suurenda vastavalt no_output_timeout väärtust. Muidu võib CircleCI vaikimisi väljundita töötamise ajalimiit peatada ka korrektselt toimiva päringutsükli. Üleslaadimine ja skannimine toimuvad enne seda ooteaega. Paiguta väljalasketööd Autonomy töö järele võtmega requires, et ebaõnnestunud kontroll takistaks edasiviimist.

Harude ja sündmuste strateegia

Need näited käivituvad harus staging. Laienda filters ainult usaldatud harudele. Kasuta ülevaadatud eelvaatemuudatuste jaoks väikest smoke-plaani ning väljalasete või ajastatud töövoogude jaoks suuremaid plaane. Seadista CircleCI projektis ühendatud VCS-i jaoks push'i, pull request'i või ajastatud käivitajad; harufiltrid ise neid ei loo.

Hoia Pass secrets to builds from forked pull requests välja lülitatuna, kui see seade on saadaval. Vaata ebausaldusväärne kood üle enne selle käivitamist töös, millel on organisatsiooni API võti, ja piira jagatud kontekstid ettenähtud projektide ning usaldatud kasutajatega. Päringu ID ühendab töövoo ja töö numbri: uus katse saab luua uue käivituse, kuid sama katse korduspäring on idempotentne.

Teenusepakkuja viited

Kontrollitud CircleCI avaliku dokumentatsiooni põhjal 20. septembril 2026:

Bitrise

Käivita Autonomy Bitrise’ist ja seo töövoo tulemus veebi, iOS-i simulaatori või Androidi käivituse otsusega.

Vercel

Käivita QA automaatselt iga Verceli eelvaate juurutuse vastu ja teata tulemus juurutuse kontrollina.

On this page

Töövoo paigutusNõutavad saladusedVeebi eelvaate-URLMobiili artefakti üleandmineiOSAndroidTöövoo jätkamise sidumine tulemusegaHarude ja sündmuste strateegiaTeenusepakkuja viited