Alusta Autonomy käivitusi Jenkinsist eelvaate URL-i või mobiilibuildi jaoks ja kukuta build läbi, kui iga käivitus ei läbi.

Lisa Autonomy Jenkinsi Pipeline'i pärast eelvaate juurutust või mobiilibuildi. Sellel lehel on jagatud abiskript ja kolm terviklikku Jenkinsfile'i; vali oma platvormi oma. Build läbib ainult siis, kui iga käivitus on Passed.

Koht töövoos

Kasuta Pipeline-tööd valikuga Pipeline script from SCM, mis viitab usaldusväärsele harule ja sinu hoidla failile Jenkinsfile. Lisa selle kõrvale commit'i .ci/autonomy.sh, loo allolevad mandaadid ja klõpsa Build Now. Webhooki ega Multibranch Pipeline'i pole vaja.

Olemasolevas pipeline'is pane Autonomy etapp pärast seda, kui juurutus on lõppenud ja eelvaade vastab. Veebinäide kasutab juba juurutatud URL-i. Dünaamilise eelvaate puhul eemalda sidumine autonomy-preview-url ja sea env.PREVIEW_URL oma juurutusetapis enne seda etappi.

Paigalda pluginad Pipeline, Pipeline: Declarative, Git ja Credentials Binding koos nende sõltuvustega. Paku Linuxi agenti sildiga linux, millel on Bash, Git, jq ja curl 7.76 või uuem. Sildid valivad sinu agendid; Jenkins ei paku majutatud Linuxi ega macOS-i masinaid.

Vajalikud saladused

Lisa lehel Manage Jenkins → Credentials Secret text mandaadid, mida see töö näeb. Hoia ID-d täpselt näidatud kujul. Loo ainult need kirjed, mida sinu platvorm vajab.

Mandaadi ID	Väärtus
`autonomy-api-key`	Organisatsiooni API-võti, mis algab eesliitega `aut_`. Omanikud ja administraatorid loovad võtmeid lehel Organization → API keys.
`autonomy-web-plan-id`	Sinu veebi testiplaani ID: aadressi `/p/<project>/plans/<id>` viimane osa lehel Test plans.
`autonomy-preview-url`	Veebinäite jaoks lõplik HTTPS-eelvaate URL.
`autonomy-ios-plan-id`	Sinu iOS-i testiplaani ID.
`autonomy-ios-bundle-id`	Ehitatud rakenduse bundle ID, näiteks `com.example.app`.
`autonomy-android-plan-id`	Sinu Androidi testiplaani ID.
`autonomy-android-package-name`	Ehitatud APK rakenduse ID, näiteks `com.example.app`.

Loo testiplaan, milles on vähemalt üks selle platvormi testjuhtum. Kui soovid hoopis üht testjuhtumit käivitada, seo selle ID (aadressist /p/<project>/tests/<id>) muutujaga AUTONOMY_TEST_CASE_ID muutuja AUTONOMY_TEST_PLAN_ID asemel. Sea täpselt üks neist kahest.
Tee eelvaade internetist kättesaadavaks. URL, millele pääseb ligi ainult Jenkins, ei tööta.
Need näited saadavad URL-i või buildi otse, ilma keskkonnata, seega pole käivitustel keskkonna väärtusi: samm, mis kasutab {{env.NAME}} väärtust, lõpeb tulemusega Couldn't start. Kui soovid hoopis kasutada sama projekti salvestatud keskkonda koos selle sihtmärkide ja väärtustega, sea AUTONOMY_ENVIRONMENT_SLUG selle slug'iks; abiskript jätab siis üleslaadimise vahele.

withCredentials lisab väärtused ainult API-kutse ümber. Ühekordsetes jutumärkides Groovy shell-plokid jätavad laiendamise Bashi hooleks; hoia set +x alles ja ära kunagi prindi võtit.

Veebieelvaate URL

Salvesta see jagatud abiskript failina .ci/autonomy.sh. Kõik kolm allolevat Jenkinsfile'i kasutavad sama faili. See alustab käivitused, prindib nende ID-d ja ootab iga tulemust.

.ci/autonomy.sh

#!/usr/bin/env bash
# Usage: bash .ci/autonomy.sh web|ios|android
# Starts Autonomy runs for this CI job and exits 0 only if every run passed.
set -euo pipefail
set +x
: "${AUTONOMY_API_KEY:?Set an aut_ organization API key}"
: "${AUTONOMY_REQUEST_ID:?Set an ID that is unique for this CI job attempt}"
platform="${1:?Usage: bash .ci/autonomy.sh web|ios|android}"
api="${AUTONOMY_API_URL:-https://api.autonomyqa.com}"
api="${api%/}"

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

# 1. What to run: a test plan or one test case.
if [ -n "${AUTONOMY_TEST_PLAN_ID:-}" ] && [ -z "${AUTONOMY_TEST_CASE_ID:-}" ]; then
  what=$(jq -n --arg id "$AUTONOMY_TEST_PLAN_ID" '{testPlanId:$id}')
elif [ -n "${AUTONOMY_TEST_CASE_ID:-}" ] && [ -z "${AUTONOMY_TEST_PLAN_ID:-}" ]; then
  what=$(jq -n --arg id "$AUTONOMY_TEST_CASE_ID" '{testCaseId:$id}')
else
  echo 'Set exactly one of AUTONOMY_TEST_PLAN_ID or AUTONOMY_TEST_CASE_ID.' >&2
  exit 2
fi

# 2. Where to run: a saved environment, or this job's preview URL or build.
if [ -n "${AUTONOMY_ENVIRONMENT_SLUG:-}" ]; then
  where=$(jq -n --arg slug "$AUTONOMY_ENVIRONMENT_SLUG" '{environmentSlug:$slug}')
else
  case "$platform" in
    web)
      : "${PREVIEW_URL:?Set PREVIEW_URL, or AUTONOMY_ENVIRONMENT_SLUG}"
      where=$(jq -n --arg url "$PREVIEW_URL" '{targets:{web:{baseUrl:$url}}}')
      ;;
    ios|android)
      : "${ARTIFACT_PATH:?Set the path to the zipped .app, .apk or .aab}"
      : "${APP_IDENTIFIER:?Set the iOS bundle ID or Android package name}"
      file=$(basename "$ARTIFACT_PATH")
      bytes=$(wc -c < "$ARTIFACT_PATH" | tr -d '[:space:]')
      if [ "$platform" = ios ]; then
        type=application/zip
      else
        type=application/vnd.android.package-archive
      fi
      upload=$(post /api/artifacts/upload-url "$(jq -n \
        --arg platform "$platform" --arg fileName "$file" \
        --arg contentType "$type" --argjson declaredBytes "$bytes" \
        '{platform:$platform,fileName:$fileName,contentType:$contentType,declaredBytes:$declaredBytes}')")
      storage=$(jq -er '.storageId' <<< "$upload")
      intent=$(jq -er '.intentId' <<< "$upload")
      curl --fail-with-body --silent --show-error \
        --connect-timeout 15 --max-time 600 \
        -X PUT "$(jq -er '.uploadUrl' <<< "$upload")" \
        -H "Content-Type: $type" --data-binary "@$ARTIFACT_PATH"
      scan=$(post /api/artifacts/scan "$(jq -n \
        --arg storageId "$storage" --arg intentId "$intent" \
        '{storageId:$storageId,intentId:$intentId}')")
      if [ "$(jq -r '.status' <<< "$scan")" != clean ]; then
        echo 'The build did not pass the safety check, so no run was started:' >&2
        jq -r '.findings[]?.message' <<< "$scan" >&2
        exit 1
      fi
      where=$(jq -n --arg p "$platform" --arg storageId "$storage" \
        --arg fileName "$file" --arg id "$APP_IDENTIFIER" \
        '{targets:{($p):({storageId:$storageId,sourceMode:"upload",fileName:$fileName}
          + (if $p == "ios" then {bundleId:$id} else {packageName:$id} end))}}')
      ;;
    *) echo 'Usage: bash .ci/autonomy.sh web|ios|android' >&2; exit 2 ;;
  esac
fi

# 3. Start the runs. A plan starts one run per test case.
#    The request ID's prefix (github, gitlab, ...) names the CI provider.
body=$(jq -n --argjson what "$what" --argjson where "$where" \
  --arg platform "$platform" \
  --arg branch "${AUTONOMY_BRANCH:-}" --arg pr "${AUTONOMY_PR:-}" \
  --arg commitSha "${AUTONOMY_COMMIT_SHA:-}" \
  --arg provider "${AUTONOMY_REQUEST_ID%%:*}" \
  --arg key "$AUTONOMY_REQUEST_ID:$platform" \
  '$what + $where + ({
     platforms: [$platform],
     branch: $branch,
     pr: $pr,
     deployment: ({provider: $provider, branch: $branch, commitSha: $commitSha}
       | with_entries(select(.value != ""))),
     idempotencyKey: $key
   } | with_entries(select(.value != "")))')
run_ids=$(post /api/v1/run.trigger "$body" | jq -er '.runIds[]')
printf 'Started Autonomy runs:\n%s\n' "$run_ids"

# 4. Follow each run until it ends. run.get waits up to 25 s for a change;
#    sending the last cursor back makes each call wait for something new.
deadline=$((SECONDS + ${AUTONOMY_WAIT_SECONDS:-1200}))
all_passed=true
for run_id in $run_ids; do
  cursor=null
  while :; do
    left=$((deadline - SECONDS))
    if [ "$left" -le 0 ]; then
      echo "Stopped waiting for run $run_id after AUTONOMY_WAIT_SECONDS. It keeps going in Autonomy." >&2
      exit 1
    fi
    wait_ms=$(( left < 25 ? left * 1000 : 25000 ))
    run=$(post /api/v1/run.get "$(jq -n --arg runId "$run_id" \
      --argjson cursor "$cursor" --argjson waitMs "$wait_ms" \
      '{runId:$runId,cursor:$cursor,waitMs:$waitMs}')")
    cursor=$(jq '.cursor' <<< "$run")
    status=$(jq -r '.status' <<< "$run")
    [ "$status" = queued ] || [ "$status" = running ] || break
  done

  name="$(jq -r '.testCaseName' <<< "$run") ($run_id)"
  case "$status" in
    passed)
      echo "Passed: $name" ;;
    failed)
      echo "Failed: $name. Open the run in Autonomy to see which step failed." >&2
      all_passed=false ;;
    couldnt_start)
      echo "Couldn't start: $name. The environment couldn't be tested, so this says nothing about your app. Open the run for the reason, fix it and run again." >&2
      all_passed=false ;;
    cancelled)
      echo "Cancelled: $name." >&2
      all_passed=false ;;
    *)
      echo "Unexpected status $status: $name." >&2
      all_passed=false ;;
  esac
done

if [ "$all_passed" != true ]; then
  echo 'Not every Autonomy run passed.' >&2
  exit 1
fi
echo 'Every Autonomy run passed.'

Salvesta see veebitöö jaoks failina Jenkinsfile. Kolme ülaltoodud veebimandaadiga töötab esimene käsitsi build ilma tööparameetriteta.

Jenkinsfile

pipeline {
  agent { label 'linux' }
  options {
    skipDefaultCheckout(true)
    timeout(time: 30, unit: 'MINUTES')
  }
  stages {
    stage('Checkout') {
      steps { checkout scm }
    }
    stage('Autonomy web') {
      steps {
        withCredentials([
          string(credentialsId: 'autonomy-api-key', variable: 'AUTONOMY_API_KEY'),
          string(credentialsId: 'autonomy-web-plan-id', variable: 'AUTONOMY_TEST_PLAN_ID'),
          string(credentialsId: 'autonomy-preview-url', variable: 'PREVIEW_URL')
        ]) {
          sh '''#!/usr/bin/env bash
set -euo pipefail
set +x
export AUTONOMY_REQUEST_ID="jenkins:${JOB_NAME}:${BUILD_NUMBER}"
export AUTONOMY_BRANCH="${BRANCH_NAME:-${GIT_BRANCH:-manual}}"
export AUTONOMY_COMMIT_SHA="$(git rev-parse HEAD)"
bash .ci/autonomy.sh web
'''
        }
      }
    }
  }
}

Mobiiliartefakti üleandmine

Kasuta iga platvormi jaoks eraldi testiplaani. Jäta veebijaotise .ci/autonomy.sh alles ja asenda Jenkinsfile vajaliku näitega. iOS-i ja Androidi puhul küsib abiskript üleslaadimise URL-i, laadib buildi üles, ootab, kuni turvakontroll tuleb puhtana tagasi, ja alustab seejärel käivitused.

iOS

iOS-i testimine tuleb peagi. Hoia see alles ajaks, mil see on saadaval. Seni ei alusta Autonomy iOS-is käivitusi.

Paku macOS-i agenti sildiga macos, millel on Xcode, selle Simulator SDK, Git ja zip. Jenkinsil pole majutatud macOS-i masinaid, seega kasuta oma Maci. Paigalda enne xcodebuild käsku oma projekti sõltuvused ning asenda MyApp, selle tööruumi tee ja väljundi nimi enda omadega.

Ehita simulaatori .app, mitte seadme .ipa. zip -y säilitab sümbolingid ja zip säilitab käivitusõigused. stash annab zip-faili edasi Linuxi etapile, mis laadib selle üles muutmata kujul. Suurte rakenduste puhul seadista Jenkinsi kaugartefaktide haldur, et stash'imine ei koormaks kontrollerit.

Jenkinsfile

pipeline {
  agent none
  options { skipDefaultCheckout(true) }
  stages {
    stage('Build iOS simulator app') {
      agent { label 'macos' }
      options { timeout(time: 60, unit: 'MINUTES') }
      steps {
        checkout scm
        sh '''#!/usr/bin/env bash
set -euo pipefail
xcodebuild \
  -workspace ios/MyApp.xcworkspace \
  -scheme MyApp \
  -configuration Release \
  -sdk iphonesimulator \
  -destination 'generic/platform=iOS Simulator' \
  -derivedDataPath ios/build \
  CODE_SIGNING_ALLOWED=NO build
mkdir -p .build
rm -f .build/MyApp.app.zip
(cd ios/build/Build/Products/Release-iphonesimulator && \
  zip -qry "$WORKSPACE/.build/MyApp.app.zip" MyApp.app)
'''
        stash name: 'ios-simulator', includes: '.build/MyApp.app.zip'
      }
    }
    stage('Autonomy iOS') {
      agent { label 'linux' }
      options { timeout(time: 35, unit: 'MINUTES') }
      steps {
        checkout scm
        unstash 'ios-simulator'
        withCredentials([
          string(credentialsId: 'autonomy-api-key', variable: 'AUTONOMY_API_KEY'),
          string(credentialsId: 'autonomy-ios-plan-id', variable: 'AUTONOMY_TEST_PLAN_ID'),
          string(credentialsId: 'autonomy-ios-bundle-id', variable: 'APP_IDENTIFIER')
        ]) {
          sh '''#!/usr/bin/env bash
set -euo pipefail
set +x
export ARTIFACT_PATH='.build/MyApp.app.zip'
export AUTONOMY_REQUEST_ID="jenkins:${JOB_NAME}:${BUILD_NUMBER}"
export AUTONOMY_BRANCH="${BRANCH_NAME:-${GIT_BRANCH:-manual}}"
export AUTONOMY_COMMIT_SHA="$(git rev-parse HEAD)"
bash .ci/autonomy.sh ios
'''
        }
      }
    }
  }
}

Android

Paku agenti sildiga linux-android, millel on Bash, Git, jq, curl 7.76 või uuem, sinu Gradle'i versioonile vastav JDK ja Androidi SDK paketid, mida su projekt vajab. Sea agendil JAVA_HOME ja ANDROID_HOME ning nõustu SDK litsentsidega. Näide eeldab käivitatavat Gradle'i wrapper'it asukohas android/gradlew; kohanda kausta ja APK teed oma projekti järgi. Build ja üleslaadimine jagavad tööruumi. Sobib ka .aab.

Jenkinsfile

pipeline {
  agent { label 'linux-android' }
  options {
    skipDefaultCheckout(true)
    timeout(time: 60, unit: 'MINUTES')
  }
  stages {
    stage('Build Android APK') {
      steps {
        checkout scm
        sh '''#!/usr/bin/env bash
set -euo pipefail
cd android
./gradlew --no-daemon assembleDebug
'''
      }
    }
    stage('Autonomy Android') {
      steps {
        withCredentials([
          string(credentialsId: 'autonomy-api-key', variable: 'AUTONOMY_API_KEY'),
          string(credentialsId: 'autonomy-android-plan-id', variable: 'AUTONOMY_TEST_PLAN_ID'),
          string(credentialsId: 'autonomy-android-package-name', variable: 'APP_IDENTIFIER')
        ]) {
          sh '''#!/usr/bin/env bash
set -euo pipefail
set +x
export ARTIFACT_PATH='android/app/build/outputs/apk/debug/app-debug.apk'
export AUTONOMY_REQUEST_ID="jenkins:${JOB_NAME}:${BUILD_NUMBER}"
export AUTONOMY_BRANCH="${BRANCH_NAME:-${GIT_BRANCH:-manual}}"
export AUTONOMY_COMMIT_SHA="$(git rev-parse HEAD)"
bash .ci/autonomy.sh android
'''
        }
      }
    }
  }
}

Pipeline'i sidumine tulemusega

Abiskript alustab käivitused päringuga POST /api/v1/run.trigger ja prindib nende ID-d. Testiplaan alustab iga testjuhtumi kohta ühe käivituse. Seejärel jälgib see iga käivitust päringuga POST /api/v1/run.get, saates tagasi viimase cursor väärtuse koos waitMs: 25000, nii et iga kutse ootab, kuni käivitus muutub. Vastus timedOut: true tähendab ainult, et midagi pole veel muutunud. Vaata Käivitused ja välised tõendid.

Käivituse tulemus	Töö	Mida logi ütleb
Passed	Läbib, kui ka kõik teised käivitused läbisid. Ebastabiilne läbimine loeb läbinuks.	`Passed`
Failed	Kukub läbi.	Ava käivitus, et näha, milline samm läbi kukkus ja miks, sealhulgas Runner problem.
Couldn't start	Kukub läbi.	Keskkonda ei saanud testida, näiteks build ei paigaldunud või mõni väärtus puudus. See ei ütle sinu rakenduse kohta midagi; paranda põhjus ja käivita uuesti.
Cancelled	Kukub läbi.	`Cancelled`

Töö kukub läbi ka API-vigade, turvakontrollist mitte läbi tulnud buildi ja ooteaja lõppemise korral. AUTONOMY_WAIT_SECONDS on kõigi käivituste kogu ooteaeg, vaikimisi 1200 sekundit. Hoia CI-töö ajalimiit sellest pikem, lisades buildi ja üleslaadimise aja. CI-töö peatamine ei tühista juba alanud käivitusi.

AUTONOMY_REQUEST_ID koos lisatud platvormiga saab päringu run.trigger väärtuseks idempotencyKey: kui sama tööpüüe saadab päringu uuesti, saab see uute asemel tagasi samad käivitused. Anna igale tööpüüdele oma ID. Esimese koolonini ulatuv osa saadetakse juurutuse pakkujana ning haru ja commit saadetakse koos käivitustega. Päringu ja vastuse täielik kuju on lehel Toimingud.

Nullist erinev väljumiskood kukutab Jenkinsi etapi läbi. Pikemate plaanide puhul suurenda Jenkinsi timeout väärtust koos muutujaga AUTONOMY_WAIT_SECONDS.

Harude ja sündmuste strateegia

Alusta käsitsi buildidega usaldusväärsest vaikeharust. Kui juurutuse üleandmine töötab, lisa tööle oma olemasolev SCM-päästik või ajakava. Kasuta usaldusväärsete muudatuste buildide puhul lühikesi suitsutesti plaane ning väljalaske- või ajastatud buildide puhul suuremaid plaane.

Väljavõetud skriptid saavad neid mandaate lugeda. Ära käivita nendega ebausaldusväärse pull request'i Jenkinsfile'i ega abiskripti, isegi kui selle haru nimi vastab filtrile. Kasuta heakskiidetud eelvaate URL-i testimiseks usaldusväärset tööd. Hoia agendid, millel need mandaadid on, lahus agentidest, mis käivitavad ebausaldusväärseid töid.

Teenusepakkuja viited

Näited kasutavad dokumenteeritud deklaratiivse Pipeline'i süntaksit, Secret text sidumisi, samme stash ja unstash ja Jenkinsi agente. Pipeline from SCM seadistamise kohta vaata Jenkinsfile'i kasutamine.

Jenkins

On this page