Continuous Integration

Derzeit bieten wir zwei Produkte an:

• Repeato Studio: Eine Desktop-App, mit der du ganz einfach Tests und Testbatches erstellen und bearbeiten kannst ➡ Dokumentation
• Repeato CLI: Eine Headless-Node.js-Anwendung zum Ausführen von Tests, mit der du Testbatches auf einem Server ausführen kannst. ➡ Dokumentation

Derzeit bieten wir keine Cloud-Dienste zum Ausführen deiner Tests an.

Du kannst unseren Test Runner jedoch verwenden, um Tests auf Drittanbieterdiensten wie Github Actions, Bitrise, Codemagic oder CircleCI auszuführen.

Da diese Dienste nur virtuelle Geräte unterstützen, empfehlen wir außerdem, deine Tests auf denselben virtuellen Geräten aufzuzeichnen. So erzielst du die beste Teststabilität und Leistung.

Bevor du deine Remote-Testpipeline einrichtest, musst du sicherstellen, dass dein Test-Workspace auf einen Remote-Server (z. B. Github) gepusht wurde.

→ Hier erfährst du, wie du mit Git die Versionierung deines Workspace startest.

Obwohl die Repeato CLI auf praktisch jedem Server ausgeführt werden kann, bieten wir derzeit 4 Einrichtungsanleitungen an (weitere folgen):

• Bitrise
• Github Actions
• Codemagic
• Appcircle
• Dein eigener Server

Bitrise

Setup

Füge deinem Workflow im Bitrise Workflow Editor einen Schritt „Repeato Test Runner“ hinzu. Du kannst den Schritt „Repeato Test Runner“ auch direkt mit Bitrise CLI.

Der Schritt prüft die Systemanforderungen und installiert sowie startet den headless Repeato CLI-Test-Runner. Nach der Ausführung der Tests setzt er die Umgebungsvariablen, die in nachfolgenden Schritten verwendet werden können.

Setup-Schritte

1. Füge den Repeato Test Runner -Schritt als einen der Schritte in deinem Workflow hinzu.
2. Stelle sicher, dass dein Test-Workspace ausgecheckt ist.
3. Setze den Workspace Path auf das Verzeichnis des Repeato-Workspaces.
4. Setze den Batch-ID. Die Batch-ID des Test-Batches, den du ausführen möchtest.
5. Setze den Repeato Access Token(kann hier).

erstellt werden) AVD oder der iOS-Emulator korrekt konfiguriert ist. Außerdem muss dein Android-/iOS-App-Build vor der Ausführung des Test-Batches auf dem Emulator installiert sein. Wir empfehlen, die Tests auf demselben Gerät bzw. Emulator auszuführen, den du ursprünglich zum Erstellen verwendet hast. So erreichst du die höchste Stabilität und Performance.

Für iOS-Simulatoren gibt es keinen Schritt zum Starten des Simulators, da der xcodebuild test Befehl für den iOS-Testschritt den Simulator standardmäßig startet.

Eingaben

repeato-workspace

Ausgaben

repeato-workspace

Tipps und Fehlerbehebung

Der Emulator benötigt etwas Zeit zum Starten. Je früher du den Schritt in deinem Workflow platzierst, desto mehr Aufgaben wie Klonen oder Caching kannst du in deinem Workflow erledigen, bevor der Emulator aktiv wird. Wir empfehlen außerdem, dass du ebenfalls Auf Android-Emulator warten Schritt (im Fall von Android) zu deinem Workflow hinzu, da er als Schutzschild verhindert, dass der AVD Manager zu früh gestartet wird. Stelle sicher, dass du den Auf Android-Emulator warten Schritt VOR dem Repeato Test Runner Step damit unser Schritt AVD Manager.

Demo-Pipeline (Android / Flutter)

Hier ist unsere Demo-Pipeline auf Bitrise, die wir für das Testen unseres Schritts eingerichtet haben (bitrise.yml kann hier heruntergeladen werden):

1. AVD Manager
2. Git-Repository klonen
3. Flutter installieren zum Erstellen unserer Flutter-basierten App.
4. Bitrise-Cache abrufen
5. Bitrise-Cache speichern
6. Auf Android-Emulator warten
7. Skript – Da unser nächster und letzter Repeato-Schritt einen vollständig bereiten und konfigurierten Emulator benötigt, verwenden wir Befehle zum Erstellen der APK (flutter build apk --split-per-abi) und zum Senden an den Emulator mit adb install (stelle sicher, dass du die mit deinen Emulator-Einstellungen kompatible APK sendest/installierst x86_64 or arm64 usw.). Je nach App musst du möglicherweise einen anderen Schritt zum Erstellen und Senden an das Gerät konfigurieren. Stelle außerdem sicher, dass vor dem nächsten Schritt die Workspace-Tests geklont wurden (falls sie sich in einem separaten Repository befinden) – siehe Useful links Abschnitt weiter unten.
8. Repeato Test Runner-Schritt
9. Auf Bitrise.io bereitstellen – Artefakte Der Repeato-Schritt kopiert die batch-reports ZIP-Datei und die JUnit-XML-Datei in das Bitrise-Upload-Verzeichnis ($BITRISE_DEPLOY_DIR). Mit diesem Schritt kannst du die Berichte in den Testartefakt-Bereich hochladen. Du kannst auch FTP Upload oder einen Deploy to S3 Schritt zum Hochladen der Berichte verwenden.
10. Testergebnisse in das Test Reports Add-on exportieren Dieser Schritt exportiert die Ergebnisse in das Test Reports Add-on. Der Schritt erstellt die erforderliche Datei test-info.json und stellt die Testergebnisse im richtigen Verzeichnis für den Export bereit.

Nützliche Links

• Erste Schritte mit dem AVD Manager
• Gradle Runner zum Erstellen
• Android-Build

GitHub Actions

Repeato CLI-Integration mit GitHub Actions

Diese Anleitung erklärt, wie du Repeato CLI in GitHub Actions integrierst und den standardmäßigen Demo-Workspace durch deinen eigenen Repeato Workspace.

---

Voraussetzungen

Stelle vor dem Start sicher, dass du Folgendes hast:

• Ein GitHub-Konto
• Repeato Studio installiert
• Einen Repeato Workspace
• Android-APK-Datei
• Repeato-Zugriffstoken

---

Schritt 1: Repeato Workspace öffnen

1. Öffne Repeato Studio
2. Klicke auf Workspace im oberen Menü
3. Kopiere die Workspace Path

Beispiel:

C:\Users\UserName\RepeatoWorkspace

---

Schritt 2: Git im Repeato Workspace initialisieren

Öffne Terminal / Eingabeaufforderung und navigiere zu deinem Workspace.

Führe Folgendes aus: cd [workspace-path]

Beispiel: cd C:\Users\UserName\RepeatoWorkspace

Git initialisieren:

• git init
• ```git add .`
• git commit -m "Initial commit" Dadurch wird dein Repeato Workspace in ein Git-Repository umgewandelt.

---

Schritt 3: GitHub-Repository erstellen

1. Öffne GitHub
2. Klicke auf Neues Repository
3. Neues Repository erstellen

Beispiel für einen Repository-Namen:

repeato-workspace

Füge beim Erstellen des Repositorys keine README-Datei hinzu.

---

Schritt 4: Workspace auf GitHub pushen

Kopiere die URL deines GitHub-Repositorys.

Beispiel: https://github.com/yourusername/repeato-workspace.git

Führe Folgendes aus:

git branch -M main

git remote add origin https://github.com/yourusername/repeato-workspace.git

git push -u origin main

---

Schritt 5: Repeato-Zugriffstoken auf GitHub hinzufügen

1. Melde dich im Repeato Client Center an

2. Navigiere zu: Account → Access Tokens

3. Klicke auf das Kopieren-Symbol neben deinem Token.

4. Öffne dein GitHub-Repository.

5. Navigiere zu: Settings → Secrets and variables → Actions

6. Klicke auf Neues Repository-Geheimnis

Füge Folgendes hinzu:

Name des Geheimnisses-REPEATO_ACCESS_TOKEN

Wert des Geheimnisses- Füge das kopierte Repeato-Zugriffstoken ein.

1. Klicke auf Geheimnis hinzufügen.

Deine GitHub Action kann sich jetzt über die Repeato CLI authentifizieren.

Beispiel

Wenn dein Workflow Folgendes enthält:

env:
REPEATO_ACCESS_TOKEN: ${{ secrets.REPEATO_ACCESS_TOKEN }}

GitHub verwendet automatisch das Token, das du in den Repository Secrets gespeichert hast.

**Wichtig:**Füge das Zugriffstoken nicht direkt in die YAML-Datei ein. Speichere es aus Sicherheitsgründen immer in GitHub Secrets .

---

Schritt 6: Workflow-Datei erstellen

Erstelle in deinem GitHub-Repository diese Ordnerstruktur: .github/workflows/

Erstelle eine Datei: workflow.yml

---

Schritt 7: GitHub-Workflow-Konfiguration hinzufügen

Füge die folgende Konfiguration in workflow.yml.

name: Integration with REPEATO CLI
on: [push, workflow_dispatch]
permissions:
  contents: write

jobs:
  repeato-cli:
    name: Build and run repeato tests using Repeato CLI
    runs-on: ubuntu-latest
    steps:
      # Configure Node.js. Version 20 required by @repeato/cli-testrunner >= 1.9 (sharp dependency)
      - uses: actions/setup-node@v4
        with:
          node-version: '20'

      # Validate Repeato access token
      - name: Validate Repeato access token
        env:
          REPEATO_ACCESS_TOKEN: ${{ secrets.REPEATO_ACCESS_TOKEN }}
        run: |
          if [ -z "$REPEATO_ACCESS_TOKEN" ]; then
            echo "REPEATO_ACCESS_TOKEN secret is not set."
            exit 1
          fi

      # Check out the app source code
      - uses: actions/checkout@v4

      # Check out the Repeato test workspace
      - name: Checkout workspace repo
        uses: actions/checkout@v4
        with:
          repository: repeato-qa/demo-workspace
          path: workspace-tests
          clean: false

      # Enable KVM for hardware-accelerated Android emulation on Ubuntu
      - name: Enable KVM group perms
        run: |
          echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
          sudo udevadm control --reload-rules
          sudo udevadm trigger --name-match=kvm
          mkdir -p ~/.android/avd

      # Start emulator and run the tests via npx @repeato/cli-testrunner
      - name: run tests
        uses: reactivecircus/android-emulator-runner@d7b53ddc6e44254e1f4cf4a6ad67345837027a66
        timeout-minutes: 20
        env:
          REPEATO_ACCESS_TOKEN: ${{ secrets.REPEATO_ACCESS_TOKEN }}
          ANDROID_AVD_HOME: /home/runner/.android/avd
        with:
          api-level: 29
          arch: x86_64
          target: google_apis
          profile: pixel_3a
          force-avd-creation: false
          emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none -no-metrics
          disable-animations: true
          script: |
            adb kill-server
            adb start-server
            npx @repeato/cli-testrunner --workspaceDir "${GITHUB_WORKSPACE}/workspace-tests" --batchId 0 --accessToken "$REPEATO_ACCESS_TOKEN" --outputDir "${GITHUB_WORKSPACE}/batch-report"

      # Upload the batch test report (screenshots + results) even on failure, for debugging
      - name: Upload test report
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: batch-report
          path: batch-report/

---

Schritt 8: Repository-Namen aktualisieren

Ersetze diese Zeile: repository: yourusername/repeato-workspace

---

Schritt 9: Änderungen committen und pushen

Führe Folgendes aus:

git add .
git commit -m "Added Repeato GitHub workflow"
git push

---

Schritt 10: GitHub Action überprüfen

1. Öffne dein GitHub-Repository
2. Klicke auf Actions

Du solltest Folgendes sehen:Integration with REPEATO CLI wird automatisch ausgeführt.

Der Workflow wird:

• Android-Emulator starten
• Repeato-Workspace herunterladen
• Repeato-Tests ausführen
• Testbericht erstellen
• Batch-Report-Artefakt hochladen

---

Wichtige Hinweise

• Ersetze die URL des GitHub-Repositorys durch die URL deines eigenen Repositorys.
• Ersetze repeato-workspace durch den tatsächlichen Namen deines Workspace-Repositorys, falls dieser abweicht.
• Stelle sicher, dass REPEATO_ACCESS_TOKEN in GitHub Secrets hinzugefügt wurde.
• Node.js-Version 20 ist für neuere Versionen der Repeato CLI erforderlich.

Codemagic

Codemagic ist ein cloudbasierter Service für Continuous Integration und Delivery (CI/CD), mit dem Entwickler ihre mobilen Apps für mehrere Plattformen erstellen, testen und bereitstellen können. Codemagic ist Teil des Flutter-Ökosystems und unterstützt sowohl Flutter- als auch React-Native-Apps. Codemagic hilft Entwicklern dabei, viele Aufgaben beim Erstellen mobiler Apps zu automatisieren, darunter das Testen, Erstellen und Bereitstellen in App Stores.

Setup-Schritte

Hier sind die folgenden Schritte:

1. Gehe zu www.codemagic.io. Erstelle ein Konto, falls du noch keines hast
2. Erstelle ein neues Codemagic-Projekt und wähle dein Git-Repository aus.
3. Wähle die Plattform, für die du bauen möchtest (iOS, Android oder beide).
4. Konfiguriere die Build-Einstellungen, einschließlich Build-Typ, Versionsnummer und Bundle-Identifier.
5. Füge erforderliche Umgebungsvariablen oder Secrets hinzu.
6. Teste deinen Workflow: Erstelle einen Build und warte, bis er abgeschlossen ist.

Beispiel-Workflows

Das macht der Workflow, sobald du Änderungen in dein Git-Repository pushst:

1. Build-Workflow:

Umgebung einrichten 2. Flutter einrichten/installieren 3. Flutter APK-Build 4. Generierte APK hinzufügen Build-Artefakte

Testausführungs-Workflow

1. Umgebung mit Node- und Flutter-Version einrichten
2. Emulator starten
3. App im Emulator installieren
4. Tests Repeato ausführen
5. Testberichte in einen Repeato S3-Bucketveröffentlichen
6. Optional nach Abschluss des Builds eine Benachrichtigung in Slack senden
7. Wenn der Build fehlschlägt, erhältst du eine Benachrichtigung und kannst das Problem untersuchen.

workflows:
  build-workflow:
    name: Build Workflow
    instance_type: mac_pro
    max_build_duration: 120
    environment:
      node: 16.19.0
      flutter: 3.0.1
      groups:
        - standard
    scripts:
      - name: Set up local.properties
        script: |
          #!/usr/bin/env zsh
          echo "flutter.sdk=$HOME/programs/flutter" > "$CM_BUILD_DIR/android/local.properties"
      - name: Get Flutter packages
        script: flutter packages pub get
      - name: Build apk with Flutter
        script: flutter build apk
    publishing:
      scripts:
        - name: List exported files
          script: |
            ls -la $CM_EXPORT_DIR
    artifacts:
      - build/**/outputs/apk/**/*.apk
  test-android-workflow:
    name: Test Workflow
    instance_type: mac_pro
    max_build_duration: 120
    environment:
      node: 16.19.0
      flutter: 3.0.1
      groups:
        - standard
    scripts:
      - name: Set up local.properties
        script: |
          #!/usr/bin/env zsh
          echo "flutter.sdk=$HOME/programs/flutter" > "$CM_BUILD_DIR/android/local.properties"
      - name: Launch emulator
        script: |
          emulator @emulator &  # Use `emulator -list-avds` to list all emulators
          adb wait-for-device # wait for the emulator to finish loading
      - name: Install app
        script: |
          adb install app.apk
      - name: Wait for 20 seconds
        script: sleep $((20*1))
      - name: Run Repeato tests
        script: |
          npx @repeato/cli-testrunner \
          --workspaceDir "demo-workspace" \
          --logLevel "DEBUG" \
          --batchId 0 \
          --accessToken "$REPEATO_ACCESS_TOKEN" \
          --waitDurationBetweenSteps 2000 \
          --timeoutFactor 1.5 \
          --outputDir "$CM_EXPORT_DIR/batch-report"
    publishing:
      scripts:
        - name: List exported files
          script: |
            ls -la $CM_EXPORT_DIR
            ls -la $CM_EXPORT_DIR/batch-report
        - name: Publish to S3 bucket
          script: |
            sudo pip3 install awscli --upgrade
            aws s3 sync "$CM_EXPORT_DIR/batch-report" s3://repeato-batch-result-demo/batch-report
            echo "open report here: https://repeato-batch-result-demo.s3.eu-central-1.amazonaws.com/batch-report/index.html"
      slack:
        channel: '#dev'
        notify_on_build_start: false # To receive a notification when a build starts
        notify:
          success: true
          failure: true

• Repeato CLI wird derzeit offiziell nur auf den Mac-Rechnern von Codemagic unterstützt.

Appcircle

Appcircle ist eine cloudbasierte Plattform für Continuous Integration und Continuous Delivery (CI/CD), die dabei hilft, die Build-, Test- und Bereitstellungsprozesse mobiler Anwendungen zu automatisieren. Die Plattform bietet eine umfassende Auswahl an Tools und Funktionen, um diese Prozesse zu automatisieren und effizienter zu gestalten.

Mit Appcircle Self-Hosted kannst du die CI/CD-Infrastruktur außerdem auf eigenen Servern oder in einer privaten Cloud-Umgebung hosten und erhältst vollständige Kontrolle und Eigentümerschaft über die Infrastruktur.

Voraussetzungen

Bevor du beginnst, stelle Folgendes sicher:

• Ein aktives Konto bei Appcircle und Repeato
• Zugriff auf dein Projekt in Appcircle und Repeato
• Der Quellcode deiner mobilen Anwendung ist in einem Versionskontrollsystem gespeichert (z. B. GitHub, Bitbucket, GitLab)

CI/CD-Workflow konfigurieren

1. Öffne in Appcircle die Build-Seite deines Projekts und wähle den Tab „Workflows“ aus.
2. Um Repeato in den Workflow zu integrieren, klicke auf „Manage Workflow“ und füge „Repeato Test Runner“ aus der Liste der verfügbaren Schritte hinzu.
3. Füge für iOS den Schritt „Xcodebuild for iOS Simulator“ oder für Android „Wait for Android Emulator“ vor dem Schritt „Repeato Test Runner“ hinzu.
4. Füge nach dem Schritt „Repeato Test Runner“ den Schritt „Test Reports“ hinzu. Dadurch werden die Testergebnisse auf der Build-Seite angezeigt.
5. Konfiguriere den Repeato-Schritt mit den erforderlichen Parametern „Batch ID“, „Access Token“ und „CLI Version“ anhand der Informationen aus Repeato.
6. Konfiguriere die übrigen Felder „Workspace Path“ und „Log Level“ mit den erforderlichen Informationen.
7. Speichere die Workflow-Konfiguration.

Wichtiger Hinweis: Aktiviere für den Schritt „Test Reports“ die Option „Always run this step even if the previous steps fail“. So erhältst du Berichte für erfolgreiche und fehlgeschlagene Tests.

CI/CD-Workflow ausführen

1. Starte den Workflow manuell oder konfiguriere automatische Trigger, etwa bei Commit- oder Merge-Ereignissen, ganz nach Bedarf.
2. Appcircle startet den Workflow mit den Build-, Test- und Bereitstellungsschritten.
3. Der Repeato-Schritt im Workflow führt die angegebenen Testfälle und Workflows über die Repeato API aus.
4. Appcircle stellt detaillierte Logs und Berichte für jeden Schritt bereit, einschließlich der Repeato-Testergebnisse.

Weitere ausführliche Informationen und Tipps findest du auf der Appcircle-Website.