Integración continua

Actualmente ofrecemos dos productos:

Repeato Studio: Una aplicación de escritorio que te permite crear y editar fácilmente pruebas y lotes de pruebas ➡ Documentación
Repeato CLI: Una aplicación de ejecución de pruebas headless para Node.js que te permite ejecutar lotes de pruebas en un servidor. ➡ Documentación

Actualmente no ofrecemos servicios en la nube para ejecutar tus pruebas.

Sin embargo, puedes usar nuestro ejecutor de pruebas para ejecutar pruebas en servicios de terceros como Github Actions, Bitrise, Codemagic o CircleCI.

Como estos servicios solo admiten dispositivos virtuales, también recomendamos grabar tus pruebas en los mismos dispositivos virtuales. Así obtendrás la mejor estabilidad y rendimiento en las pruebas.

Antes de configurar tu pipeline de pruebas remoto, tendrás que asegurarte de que tu espacio de trabajo de pruebas se envía a algún servidor remoto (como Github).

→ Aquí se explica cómo empezar a versionar tu espacio de trabajo mediante Git.

Aunque Repeato CLI se ejecuta prácticamente en cualquier servidor, actualmente ofrecemos 4 guías de configuración (habrá más):

Bitrise
Github Actions
Codemagic
Appcircle
Tu propio servidor

Bitrise

Configuración

Añade un paso «Repeato Test Runner» a tu flujo de trabajo en el Editor de flujos de trabajo de Bitrise. También puedes ejecutar directamente el paso «Repeato Test Runner» con Bitrise CLI.

El paso se encarga de comprobar los requisitos del sistema, así como de instalar e iniciar el ejecutor de pruebas de Repeato CLI sin interfaz. Después de ejecutar las pruebas, establece las variables de entorno que pueden usarse en los pasos siguientes.

Pasos de configuración

Añade el Repeato Test Runner como paso de tu flujo de trabajo.
Asegúrate de que tu espacio de trabajo de pruebas esté descargado.
Establece la Ruta del espacio de trabajo para que apunte al directorio del espacio de trabajo de Repeato.
Establece la ID del lote. El ID del lote de pruebas que quieres ejecutar.
Establece la Repeato Token de acceso(puede crearse aquí).

Asegúrate de que el AVD o el emulador de iOS estén configurados correctamente. Además, la compilación de tu aplicación Android/iOS debe estar instalada en el emulador antes de ejecutar el lote de pruebas. Recomendamos ejecutar las pruebas en el mismo dispositivo o emulador que usaste originalmente para crearlas. Así obtendrás la máxima estabilidad y rendimiento.

Para los simuladores de iOS no hay ningún paso que inicie el simulador, ya que el xcodebuild test comando del paso de pruebas de iOS inicia el simulador de forma predeterminada.

Entradas

repeato-workspace

Salidas

repeato-workspace

Consejos y solución de problemas

El emulador necesita algo de tiempo para iniciarse. Cuanto antes coloques el paso en tu flujo de trabajo, más tareas, como clonar o almacenar en caché, podrás completar antes de que el emulador empiece a funcionar. También recomendamos añadir Esperar al emulador de Android Paso (en el caso de Android) a tu flujo de trabajo, ya que actúa como una protección que evita que el administrador de AVD se inicie demasiado pronto. Asegúrate de añadir el Esperar al emulador de Android paso ANTES del Repeato Test Runner Step para que nuestro paso pueda usar Administrador de AVD.

Pipeline de demostración (Android / Flutter)

Este es nuestro pipeline de demostración en Bitrise, que hemos configurado para probar nuestro paso (bitrise.yml se puede descargar aquí):

Flujo de automatización de pruebas de Bitrise

Administrador de AVD
Clonar repositorio de Git
Instalar Flutter para compilar nuestra aplicación basada en Flutter.
Extraer caché de Bitrise
Subir caché de Bitrise
Esperar al emulador de Android
Script - Como nuestro siguiente y último paso de Repeato necesita un emulador completamente listo y configurado, usamos comandos para compilar el APK (flutter build apk --split-per-abi) y enviarlo al emulador mediante adb install (asegúrate de enviar/instalar el APK compatible con la configuración de tu emulador x86_64 or arm64 etc.). Puede que tengas que configurar un paso diferente para compilar la aplicación y enviarla al dispositivo (según tu APP). Asegúrate también de clonar workspace-tests antes del siguiente paso (si están en un repositorio separado). Consulta la Useful links sección siguiente.
Paso de Repeato Test Runner
Implementar en Bitrise.io - Artefactos El paso de Repeato copia el archivo batch-reports zip y el archivo XML de JUnit en el directorio de carga de Bitrise ($BITRISE_DEPLOY_DIR). Puedes usar este paso para cargar los informes en la sección de artefactos de prueba. También puedes usar Carga FTP o un paso de Implementar en S3 para cargar los informes.
Exportar resultados de pruebas al complemento Test Reports Este paso exporta los resultados al complemento Test Reports. El paso crea el archivo test-info.json requerido y despliega los resultados de las pruebas en el directorio correcto para su exportación.

Enlaces útiles

GitHub Actions

Integración de Repeato CLI con GitHub Actions

Esta guía explica cómo integrar Repeato CLI con GitHub Actions y reemplazar el espacio de trabajo de demostración predeterminado por tu propio espacio de trabajo de Repeato.

Requisitos previos

Antes de comenzar, asegúrate de tener:

Una cuenta de GitHub
Repeato Studio instalado
Un espacio de trabajo de Repeato
Archivo APK de Android
Token de acceso de Repeato

Paso 1: Abrir el espacio de trabajo de Repeato

Abre Repeato Studio
Haz clic en Workspace en el menú superior
Copia el Ruta del espacio de trabajo

Ejemplo:

C:\Users\UserName\RepeatoWorkspace

Paso 2: Inicializar Git en el espacio de trabajo de Repeato

Abre Terminal / Símbolo del sistema y navega hasta tu espacio de trabajo.

Ejecuta: cd [workspace-path]

Ejemplo: cd C:\Users\UserName\RepeatoWorkspace

Inicializa Git:

git init
```git add .`
git commit -m "Initial commit" Esto convierte tu espacio de trabajo de Repeato en un repositorio de Git.

Paso 3: Crear un repositorio de GitHub

Abrir GitHub
Haz clic en Nuevo repositorio
Crear un repositorio nuevo

Nombre de repositorio de ejemplo:

repeato-workspace

No añadas un archivo README al crear el repositorio.

Paso 4: Enviar el espacio de trabajo a GitHub

Copia la URL de tu repositorio de GitHub.

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

Ejecuta:

git branch -M main

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

git push -u origin main

Paso 5: Añadir el token de acceso de Repeato en GitHub

Inicia sesión en Repeato Client Center
Ve a: Account → Access Tokens
Haz clic en el icono de copia junto a tu token.
Abre tu repositorio de GitHub.
Ve a: Settings → Secrets and variables → Actions
Haz clic en Nuevo secreto del repositorio

Añade lo siguiente:

Nombre del secreto-REPEATO_ACCESS_TOKEN

Valor del secreto- Pega el token de acceso de Repeato copiado.

Haz clic en Añadir secreto.

Tu acción de GitHub podrá autenticarse ahora con Repeato CLI.

Ejemplo

Si tu flujo de trabajo contiene:

env:
REPEATO_ACCESS_TOKEN: &#36;&#123;&#123; secrets.REPEATO_ACCESS_TOKEN &#125;&#125;

GitHub usará automáticamente el token que guardaste en los secretos del repositorio.

**Importante:**No pegues el token de acceso directamente en el archivo YAML. Guárdalo siempre en Secretos de GitHub por seguridad.

Paso 6: Crear el archivo de flujo de trabajo

Dentro de tu repositorio de GitHub, crea esta estructura de carpetas: .github/workflows/

Crea un archivo: workflow.yml

Paso 7: Añadir la configuración del flujo de trabajo de GitHub

Pega la siguiente configuración en 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: &#36;&#123;&#123; secrets.REPEATO_ACCESS_TOKEN &#125;&#125;
        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: &#36;&#123;&#123; secrets.REPEATO_ACCESS_TOKEN &#125;&#125;
          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 "&#36;&#123;GITHUB_WORKSPACE}/workspace-tests" --batchId 0 --accessToken "$REPEATO_ACCESS_TOKEN" --outputDir "&#36;&#123;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/

Paso 8: Actualizar el nombre del repositorio

Sustituye esta línea: repository: yourusername/repeato-workspace

Paso 9: Confirmar y enviar los cambios

Ejecuta:

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

Paso 10: Verificar la acción de GitHub

Abre tu repositorio de GitHub
Haz clic en Acciones

Deberías ver:Integration with REPEATO CLI ejecutándose automáticamente.

El flujo de trabajo:

Iniciará el emulador de Android
Descargará el espacio de trabajo de Repeato
Ejecutará las pruebas de Repeato
Generará el informe de pruebas
Cargará el artefacto del informe por lotes

Notas importantes

Sustituye la URL del repositorio de GitHub por la de tu propio repositorio.
Sustituye repeato-workspace por el nombre real del repositorio de tu espacio de trabajo, si es diferente.
Asegúrate de que REPEATO_ACCESS_TOKEN esté añadido en los secretos de GitHub.
Versión de Node.js 20 es necesaria para las versiones más recientes de Repeato CLI.

Codemagic

Codemagic es un servicio de integración y entrega continuas (CI/CD) basado en la nube que permite a los desarrolladores compilar, probar y desplegar sus aplicaciones móviles en varias plataformas. Forma parte del ecosistema de Flutter y es compatible con aplicaciones de Flutter y React Native. Codemagic puede ayudar a los desarrolladores a automatizar muchas de las tareas relacionadas con la creación de aplicaciones móviles, incluidas las pruebas, la compilación y el despliegue en las tiendas de aplicaciones.

Pasos de configuración

Estos son los pasos que debes seguir:

Ve a www.codemagic.io, y crea una cuenta si aún no tienes una
Crea un nuevo proyecto de Codemagic y selecciona tu repositorio de Git.
Elige la plataforma para la que quieres compilar (iOS, Android o ambas).
Configura los ajustes de compilación, incluidos el tipo de compilación, el número de versión y el identificador del paquete.
Añade las variables de entorno o los secretos necesarios.
Prueba tu flujo de trabajo: crea una compilación y espera a que finalice.

Flujos de trabajo de ejemplo

Esto es lo que hace el flujo de trabajo en cuanto envías cambios a tu repositorio de Git:

Flujo de compilación:

Configuración del entorno 2. Configuración/instalación de Flutter 3. Flutter Compilación del APK 4. Añadir el APK generado en los artefactos de compilación

Flujo de ejecución de pruebas

Configurar el entorno con la versión de Node y Flutter
Iniciar el emulador
Instalar la aplicación en el emulador
Ejecutar Repeato pruebas
Publicar los Repeato informes de pruebas en unbucket de S3
Opcionalmente, enviar una notificación a Slack cuando finalice la compilación
Si la compilación falla, recibirás una notificación y podrás investigar el problema.

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 actualmente solo es compatible oficialmente con las máquinas Mac de Codemagic.

Appcircle

Appcircle es una plataforma basada en la nube para la integración continua y la entrega continua (CI/CD) que ayuda a automatizar los procesos de compilación, pruebas y despliegue de aplicaciones móviles. Ofrece un conjunto completo de herramientas y funciones para automatizar y optimizar estos procesos.

Además, con Appcircle autohospedado, puedes alojar la infraestructura de CI/CD en tus propios servidores o en un entorno de nube privada, lo que te proporciona control y propiedad completos sobre la infraestructura.

Requisitos previos

Antes de empezar, asegúrate de tener lo siguiente:

Una cuenta activa en Appcircle y Repeato
Acceso a tu proyecto tanto en Appcircle como en Repeato
El código fuente de tu aplicación móvil almacenado en un sistema de control de versiones (p. ej., GitHub, Bitbucket o GitLab)

Configuración del flujo de trabajo de CI/CD

En Appcircle, ve a la página de compilación de tu proyecto y selecciona la pestaña «Workflows».
Para integrar Repeato en el flujo de trabajo, haz clic en «Manage Workflow» y añade «Repeato Test Runner» de la lista de pasos disponibles.
Añade el paso «Xcodebuild for iOS Simulator» para iOS o «Wait for Android Emulator» para Android, antes del paso «Repeato Test Runner».
Añade el paso «Test Reports» después del paso «Repeato Test Runner». Esto permitirá mostrar los resultados de las pruebas en la página de compilación.
Configura el paso de Repeato proporcionando los parámetros necesarios, como «Batch ID», «Access Token» y «CLI Version», con la información que obtengas de Repeato.
Configura los campos restantes, «Workspace Path» y «Log Level», con la información necesaria.
Guarda la configuración del flujo de trabajo.

Nota importante: Para el paso «Test Reports», asegúrate de activar la opción «Always run this step even if the previous steps fail». Esto garantiza que recibirás informes tanto de las pruebas correctas como de las fallidas.

Ejecución del flujo de trabajo de CI/CD

Activa el flujo de trabajo manualmente o configura activadores automáticos, como eventos de confirmación o combinación, según tus preferencias.
Appcircle iniciará el flujo de trabajo, que incluye los pasos de compilación, pruebas y despliegue.
El paso de Repeato del flujo de trabajo ejecutará los casos de prueba y flujos de trabajo especificados mediante la API de Repeato.
Appcircle proporcionará registros e informes detallados de cada paso, incluidos los resultados de las pruebas de Repeato.

Obtén información y consejos aún más detallados en el sitio web de Appcircle