Autonomy dokumentatsioon
Integratsioonid

GitLab CI

Käivita Autonomy GitLab CI-st eelvaate-URL-i, iOS Simulatori rakenduse või Androidi APK-ga ning sea töövoo jätkamine sõltuvusse tulemusest.

Käivita Autonomy pärast juurutust või mobiilirakenduse build'i ja hoia GitLabi töö avatuna, kuni igal valitud testjuhtumil on kehtiv edukas tulemus. Kopeeri ühine skript ja selle platvormi konfiguratsioon, mida sinu projekt väljastab.

Töövoo paigutus

Paiguta Autonomy pärast juurutustööd, mis leiab lõpliku eelvaate-URL-i, või pärast mobiiliartefakti ehitavat tööd. Allolev veebinäide võtab juba juurutatud URL-i ja kontrollib, et see vastaks. See ei juuruta sinu rakendust.

Iga YAML-näide on täielik alternatiivne .gitlab-ci.yml. Olemasolevasse töövoogu lisades säilita build'i- ja juurutustööd, ühenda etapid ning suuna needs URL-i või artefakti tootvale tööle. Käivita ainult usaldusväärset koodi kaitstud vaikeharul.

Vajalikud saladused

Lisa need väärtused jaotises Settings → CI/CD → Variables tüübiga Variable, mitte File, ja keskkonna skoobiga *. Kaitse muutujad ning keela muutujaviidete laiendamine. Märgi API-võti valikuga Masked and hidden. Kaitse vaikeharu enne näidete käivitamist.

  • AUTONOMY_API_KEY: organisatsiooni API-võti algusega aut_, mis on loodud Autonomy jaotises Settings → API Keys. See peab kuuluma plaani sisaldavale organisatsioonile. Organisatsiooni võtmed hõlmavad praegu kõiki API skoope.
  • AUTONOMY_API_URL: kopeeri CONVEX_SITE_URL või NEXT_PUBLIC_CONVEX_SITE_URL sinu API-võtmele vastavast juurutusest. Kasuta selle täpset Convexi HTTP-URL-i, säilitades hostinimes võimaliku piirkonna, ilma /api ja lõpus oleva rajata. Ära kasuta töölaua URL-i ega .convex.cloud aadressi. Arendusvõti vajab vastava arendusjuurutuse URL-i.
  • AUTONOMY_TEST_PLAN_ID: tegeliku Test Plans plaani ID, milles on vähemalt üks veebitestjuhtum. Kopeeri ID plaani URL-ist. Test Cases ID ei ole plaani ID-ga vahetatav.
  • PREVIEW_URL: valmis HTTPS-i eelvaate-URL veebinäite jaoks. See peab olema Autonomy runner'ist ligipääsetav, mitte localhost ega teenus, mis on nähtav ainult CI töö sees.
  • iOS-i jaoks lisa AUTONOMY_IOS_TEST_PLAN_ID ja AUTONOMY_IOS_BUNDLE_ID. Androidi jaoks lisa AUTONOMY_ANDROID_TEST_PLAN_ID ja AUTONOMY_ANDROID_PACKAGE_NAME. Iga plaan peab sisaldama selle platvormi testjuhtumeid; identifikaatorid peavad vastama ehitatud rakendusele.
  • Veendu, et soovitud platvormi Autonomy runner ja piisavad käivituskrediidid oleksid saadaval. Nende selgesõnaliste eraldiseisvate sihtmärkide puhul kasuta testjuhtumeid, mis ei viita salvestatud Environment-i käitusaegsetele väärtustele.

Näited määravad AUTONOMY_REQUEST_ID väärtuse CI_JOB_ID põhjal, nii et uuesti käivitatud GitLabi töö saab uue päringu. Haru ja commit'i metaandmed tulevad GitLabi eelmääratud muutujatest. Valitud testjuhtumite korraldamist kirjeldab Test Plans.

Veebi eelvaate-URL

Loo hoidla juurkausta .ci/, salvesta järgmine skript faili .ci/autonomy.sh ja commiti see koos töövoofailiga. Kõik selle lehe retseptid kasutavad täpselt sama skripti. See vajab Bashi, jq-d ning curl 7.76 või uuemat versiooni; konteineripõhised tööd paigaldavad need.

.ci/autonomy.sh
#!/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 järgnev faili .gitlab-ci.yml. Luba projekti jaoks GitLabi hallatud Linuxi runner'id; veebitööd ja iOS-i üleslaadimistöö valivad selgesõnaliselt saas-linux-small-amd64. GitLab Self-Managedi puhul asenda see silt igas Linuxi konteineritöös oma Linuxi Docker-executor'iga runner'i sildiga. Alusta valikust Build → Pipelines → New pipeline kaitstud vaikeharul. Kui API päringu vastu võtab, ilmuvad logisse Queued Autonomy runs: ja käivituste ID-d.

.gitlab-ci.yml
stages: [prepare, qa]

workflow:
  rules:
    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $CI_COMMIT_REF_PROTECTED == "true"'
    - when: never

default:
  tags: [saas-linux-small-amd64]
  image: debian:stable-slim
  before_script:
    - apt-get update && apt-get install -y --no-install-recommends bash curl jq ca-certificates

preview_ready:
  stage: prepare
  script:
    - |
      : "${PREVIEW_URL:?Set the deployed preview URL in CI/CD Variables}"
      curl --fail --silent --show-error --location \
        --connect-timeout 15 --max-time 60 "$PREVIEW_URL" > /dev/null
      printf 'PREVIEW_URL=%s\n' "$PREVIEW_URL" > preview.env
  artifacts:
    reports:
      dotenv: preview.env
    expire_in: 1 day

autonomy_web:
  stage: qa
  timeout: 30m
  needs:
    - job: preview_ready
      artifacts: true
  script:
    - |
      export AUTONOMY_REQUEST_ID="gitlab:$CI_PROJECT_ID:$CI_JOB_ID"
      export AUTONOMY_BRANCH="$CI_COMMIT_REF_NAME"
      export AUTONOMY_COMMIT_SHA="$CI_COMMIT_SHA"
      bash .ci/autonomy.sh web

Kui URL luuakse olemasolevas juurutustöös, liiguta printf ja artifacts:reports:dotenv kirjed sellesse töösse ning asenda needs selle nimega. Eemalda fikseeritud projekti muutuja PREVIEW_URL, et see ei kirjutaks üle genereeritud dotenv-väärtust. Ära pane mandaate faili preview.env; GitLab salvestab selle allalaaditava artefaktina.

Mobiiliartefakti üleandmine

Kasuta sama .ci/autonomy.sh skripti. See taotleb allkirjastatud üleslaadimis-URL-i, laadib faili üles, nõuab puhast skannitulemust ja edastab saadud salvestus-ID käivitusele. Vali ainult platvorm, mille build on sinu hoidlas olemas.

iOS

Kasuta eraldi kaitstud isehallatavat macOS-i runner'it sildiga macos, Bashi shell-executor'iga ning paigaldatud Xcode'i ja iOS Simulatori SDK-ga. Keela selle runner'i valik Run untagged jobs ja ära lisa sellele Linuxi runner'i silti. GitLabi hallatud macOS-i runner'id vajavad Premiumi või Ultimate'i paketti, välja arvatud sobivad avatud lähtekoodiga projektide programmid. Tavaline Free-projekt vajab oma Maci. Linux ei saa seda Xcode'i build'i teha.

See natiivne näide eeldab ios/MyApp.xcodeproj projekti, jagatud MyApp skeemi ja MyApp.app väljundit. Asenda kõik kolm oma projekti nimedega ning paigalda projektipõhised sõltuvused enne xcodebuild käsku. Workspace-projekti puhul kasuta -project asemel -workspace ios/MyApp.xcworkspace. Tulemuseks on Simulatori .app, mitte seadme .ipa.

macOS-i töö arhiveerib rakenduse, säilitades käivitusõigused ja sümboolsed lingid, enne kui GitLab ZIP-i transpordib. needs:artifacts laadib selle ZIP-i alla Linuxi töös, mis tegeleb üleslaadimise ja ootamisega.

.gitlab-ci.yml
stages: [build, qa]

workflow:
  rules:
    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $CI_COMMIT_REF_PROTECTED == "true"'
    - when: never

build_ios:
  stage: build
  tags: [macos]
  script:
    - |
      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 .build
      (cd ios/build/Build/Products/Release-iphonesimulator && \
        zip -qry -y "$CI_PROJECT_DIR/.build/MyApp.app.zip" MyApp.app)
  artifacts:
    paths:
      - .build/MyApp.app.zip
    expire_in: 1 day

autonomy_ios:
  stage: qa
  tags: [saas-linux-small-amd64]
  image: debian:stable-slim
  timeout: 30m
  needs:
    - job: build_ios
      artifacts: true
  before_script:
    - apt-get update && apt-get install -y --no-install-recommends bash curl jq ca-certificates
  script:
    - |
      export AUTONOMY_TEST_PLAN_ID="$AUTONOMY_IOS_TEST_PLAN_ID"
      export APP_IDENTIFIER="$AUTONOMY_IOS_BUNDLE_ID"
      export ARTIFACT_PATH=".build/MyApp.app.zip"
      export AUTONOMY_REQUEST_ID="gitlab:$CI_PROJECT_ID:$CI_JOB_ID"
      export AUTONOMY_BRANCH="$CI_COMMIT_REF_NAME"
      export AUTONOMY_COMMIT_SHA="$CI_COMMIT_SHA"
      bash .ci/autonomy.sh ios

Android

Registreeri eraldi kaitstud Linuxi runner sildiga android-linux ja Bashi shell-executor'iga. Keela selle runner'i valik Run untagged jobs ja ära lisa sellele Linuxi konteinerirunner'i silti. Paigalda sellesse masinasse projekti nõutav JDK, Androidi käsureatööriistad, sinu compile SDK ja build-tools versioonid, Bash, jq, curl 7.76 või uuem ning usaldusväärsed CA-sertifikaadid. Määra ANDROID_HOME, nõustu SDK litsentsidega ning lisa hoidlasse käivitatav android/gradlew koos wrapper-failidega. Shell-executor kasutab hosti tööriistu ega paigalda Androidi SDK-d sinu eest.

See näide ehitab app mooduli silumise APK ja laadib selle üles samas Linuxi töös. Kui projekt kasutab variante või teist moodulit, kohanda koos Gradle'i ülesannet ja ARTIFACT_PATH väärtust.

.gitlab-ci.yml
stages: [qa]

workflow:
  rules:
    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH && $CI_COMMIT_REF_PROTECTED == "true"'
    - when: never

autonomy_android:
  stage: qa
  tags: [android-linux]
  timeout: 60m
  script:
    - |
      set -euo pipefail
      (cd android && ./gradlew --no-daemon assembleDebug)
      export AUTONOMY_TEST_PLAN_ID="$AUTONOMY_ANDROID_TEST_PLAN_ID"
      export APP_IDENTIFIER="$AUTONOMY_ANDROID_PACKAGE_NAME"
      export ARTIFACT_PATH="android/app/build/outputs/apk/debug/app-debug.apk"
      export AUTONOMY_REQUEST_ID="gitlab:$CI_PROJECT_ID:$CI_JOB_ID"
      export AUTONOMY_BRANCH="$CI_COMMIT_REF_NAME"
      export AUTONOMY_COMMIT_SHA="$CI_COMMIT_SHA"
      bash .ci/autonomy.sh android

Töövoo jätkamise sidumine tulemusega

Skript kontrollib iga run.trigger tagastatud ID-d run.get kaudu. See ootab edasi, kuni käivituse olek on queued, running või retrying, ja õnnestub ainult siis, kui iga lõpptulemus sisaldab verdict: "passed" ja validity: "valid". Pelgalt järjekorda lisatud käivitus ei muuda töövoogu edukaks. Ebaõnnestunud, kehtetud, kontrollimata, tühistatud, ootamatud või aegunud tulemused lõpetavad töö ebaõnnestunult.

Vaikimisi on kõigi tagastatud käivituste ühine ooteaeg 1200 sekundit. Muuda seda väärtusega AUTONOMY_WAIT_SECONDS ning hoia GitLabi töö ja runner'i ajalimiidid sellest pikemad, lisades build'i ja üleslaadimise aja. Hoia allow_failure keelatuna. GitLabi töö tühistamine või ajalimiidi täitumine lõpetab pärimise, kuid ei tühista juba järjekorras olevat Autonomy käivitust.

Harude ja sündmuste strateegia

Need konfiguratsioonid lubavad push-sündmusi, ajastusi ja käsitsi käivitatud töövooge ainult kaitstud vaikeharul. Merge request'ide töövood ja fork'ide kood ei saa võtit. Kasuta tavaliste juurutuste puhul lühikesi smoke-testiplaane; versioonikontrolliks käivita laiem plaan ajastuse või käsitsi käivitatud töövooga.

Merge request'i eelvaate kontrollimiseks käivita kaitstud vaikeharu usaldusväärne konfiguratsioon käsitsi koos üle vaadatud eelvaate-URL-iga. Ära luba kaitstud muutujatele ligipääsu ebausaldusväärse merge request'i koodile. Harureeglite laiendamisel kaitse need harud ning vaata esmalt üle nende töövoomuudatused.

Teenusepakkuja viited

GitHub Actions

Käivita Autonomy GitHub Actionsist, kui eelvaate või staging'i sihtmärk on valmis.

Jenkins

Käivita Autonomy Jenkinsist eelvaate-URL-i või mobiiliartefaktiga ja märgi build ebaõnnestunuks, kui käivitus ei läbi testi.

On this page

Töövoo paigutusVajalikud saladusedVeebi eelvaate-URLMobiiliartefakti üleandmineiOSAndroidTöövoo jätkamise sidumine tulemusegaHarude ja sündmuste strateegiaTeenusepakkuja viited