Saltar al contenido

Testing Automatizado de UI en Servidores Mac: XCTest, Appium y Selenium

Configura un servidor Mac dedicado para testing automatizado de UI 24/7. Ejecuta tests XCTest, XCUITest, Appium y Selenium en paralelo a través de múltiples simuladores iOS con resultados consistentes y reproducibles.

Testing 30 min de lectura Actualizado en octubre de 2026

¿Por Qué Hardware Dedicado para Testing?

El testing de UI en máquinas compartidas o locales introduce inestabilidad, inconsistencia y cuellos de botella. Un servidor de build Mac mini M4 dedicado resuelve estos problemas.

Resultados Consistentes

Sin otros procesos compitiendo por CPU o RAM. Los tests se ejecutan en un entorno limpio y controlado cada vez, eliminando fallos inestables de tests causados por contención de recursos.

Ejecución Paralela

Ejecuta tests en múltiples instancias del iOS Simulator simultáneamente. Un Mac mini M4 Pro (CPU de 12 núcleos, 24GB) maneja 4-6 instancias paralelas del Simulator sin degradación de rendimiento.

Disponibilidad 24/7

Los tests se ejecutan en cualquier momento: suites de regresión nocturnas, validación post-merge o bajo demanda. El servidor siempre está listo, no se necesita el portátil del desarrollador.

XCTest en un Mac Dedicado

XCTest es el framework de testing integrado de Apple, incluido con Xcode. XCUITest lo extiende para testing de UI. Ambos se ejecutan de forma nativa y no requieren configuración adicional más allá de Xcode.

Ejecutar XCTest desde la Línea de Comandos

# Use any device listed by: xcrun simctl list devices available
# Run all unit tests
xcodebuild test \
  -workspace MyApp.xcworkspace \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 17,OS=latest' \
  -resultBundlePath ./TestResults/UnitTests.xcresult

# Run only UI tests
xcodebuild test \
  -workspace MyApp.xcworkspace \
  -scheme MyAppUITests \
  -destination 'platform=iOS Simulator,name=iPhone 17,OS=latest' \
  -resultBundlePath ./TestResults/UITests.xcresult

# Run a specific test class
xcodebuild test \
  -workspace MyApp.xcworkspace \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 17' \
  -only-testing:MyAppTests/LoginTests

# Run a specific test method
xcodebuild test \
  -workspace MyApp.xcworkspace \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 17' \
  -only-testing:MyAppTests/LoginTests/testSuccessfulLogin

Testing en Múltiples Destinos

# Test on multiple iPhone models simultaneously
# (each name must exist in: xcrun simctl list devices available;
#  create a missing one with: xcrun simctl create "iPhone 17e" "iPhone 17e")
xcodebuild test \
  -workspace MyApp.xcworkspace \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 17' \
  -destination 'platform=iOS Simulator,name=iPhone 18 Pro Max' \
  -destination 'platform=iOS Simulator,name=iPhone 17e' \
  -destination 'platform=iOS Simulator,name=iPad Pro 13-inch (M5)' \
  -resultBundlePath ./TestResults/MultiDevice.xcresult

# List all available destinations
xcodebuild -showdestinations \
  -workspace MyApp.xcworkspace \
  -scheme MyApp

Paquetes de Resultados y Capturas de Pantalla

# Test results summary as JSON (Xcode 16 and later)
xcrun xcresulttool get test-results summary \
  --path ./TestResults/UITests.xcresult

# Every test with its result
xcrun xcresulttool get test-results tests \
  --path ./TestResults/UITests.xcresult

# Export test attachments (screenshots, videos)
xcrun xcresulttool export attachments \
  --path ./TestResults/UITests.xcresult \
  --output-path ./TestArtifacts

Configuración de Appium para iOS

Appium es un framework de automatización de código abierto que te permite escribir tests en cualquier lenguaje (Python, JavaScript, Java, etc.) y ejecutarlos contra apps iOS en simuladores o dispositivos. Usa el driver XCUITest de Apple internamente.

Instalar Appium en Tu Servidor Mac

# Install Node.js via Homebrew
brew install node

# Install Appium globally (npm installs the latest release)
npm install -g appium

# Install the XCUITest driver for iOS
appium driver install xcuitest

# Verify installation
appium --version
appium driver list --installed

# Check the driver's requirements (Xcode, WebDriverAgent, etc.)
appium driver doctor xcuitest

# Start Appium server
appium server --address 127.0.0.1 --port 4723

Configurar Desired Capabilities

# Example capabilities (JSON format, Appium 2 and later)
# The Simulator is picked by name; add "appium:platformVersion"
# to pin a specific iOS version
{
    "platformName": "iOS",
    "appium:automationName": "XCUITest",
    "appium:deviceName": "iPhone 17",
    "appium:app": "/path/to/MyApp.app",
    "appium:noReset": false,
    "appium:wdaStartupRetries": 3,
    "appium:wdaStartupRetryInterval": 20000,
    "appium:simulatorStartupTimeout": 120000
}

Ejemplo de Test Appium (Python)

# Install Appium Python client
# pip install Appium-Python-Client

from appium import webdriver
from appium.options.ios import XCUITestOptions
from appium.webdriver.common.appiumby import AppiumBy

# Configure options
options = XCUITestOptions()
options.platform_name = "iOS"
options.device_name = "iPhone 17"
# Optional: options.platform_version pins a specific iOS version
options.app = "/path/to/MyApp.app"

# Connect to Appium server
driver = webdriver.Remote(
    command_executor="http://127.0.0.1:4723",
    options=options
)

try:
    # Wait for app to load
    driver.implicitly_wait(10)

    # Find and tap login button
    login_button = driver.find_element(
        AppiumBy.ACCESSIBILITY_ID, "loginButton"
    )
    login_button.click()

    # Enter username
    username_field = driver.find_element(
        AppiumBy.ACCESSIBILITY_ID, "usernameField"
    )
    username_field.send_keys("testuser@example.com")

    # Enter password
    password_field = driver.find_element(
        AppiumBy.ACCESSIBILITY_ID, "passwordField"
    )
    password_field.send_keys("password123")

    # Submit login
    submit_button = driver.find_element(
        AppiumBy.ACCESSIBILITY_ID, "submitButton"
    )
    submit_button.click()

    # Verify welcome screen
    welcome_label = driver.find_element(
        AppiumBy.ACCESSIBILITY_ID, "welcomeLabel"
    )
    assert "Welcome" in welcome_label.text

    print("Test PASSED: Login successful")

finally:
    driver.quit()

Ejemplo de Test Appium (JavaScript)

// npm install webdriverio @wdio/cli

const { remote } = require('webdriverio');

async function runTest() {
    const driver = await remote({
        protocol: 'http',
        hostname: '127.0.0.1',
        port: 4723,
        path: '/',
        capabilities: {
            platformName: 'iOS',
            'appium:automationName': 'XCUITest',
            'appium:deviceName': 'iPhone 17',
            'appium:app': '/path/to/MyApp.app'
        }
    });

    try {
        // Tap login button
        const loginBtn = await driver.$('~loginButton');
        await loginBtn.click();

        // Enter credentials
        const username = await driver.$('~usernameField');
        await username.setValue('testuser@example.com');

        const password = await driver.$('~passwordField');
        await password.setValue('password123');

        // Submit
        const submit = await driver.$('~submitButton');
        await submit.click();

        // Verify
        const welcome = await driver.$('~welcomeLabel');
        const text = await welcome.getText();
        console.assert(text.includes('Welcome'), 'Login test failed');

        console.log('Test PASSED: Login successful');
    } finally {
        await driver.deleteSession();
    }
}

runTest();

Selenium para Safari

macOS incluye Safari y safaridriver de serie. No se necesitan descargas adicionales de drivers de navegador, a diferencia de Chrome o Firefox en otras plataformas.

Habilitar safaridriver

# Enable the Safari WebDriver (one-time setup)
safaridriver --enable

# Verify safaridriver is working
safaridriver --version

# For headless-like automation, enable "Allow Remote Automation"
# in Safari > Settings > Advanced > Show Develop menu
# Then: Develop > Allow Remote Automation
# Or via command line:
defaults write com.apple.Safari AllowRemoteAutomation 1

Test Selenium en Safari (Python)

# pip install selenium

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Create Safari driver
driver = webdriver.Safari()

try:
    # Navigate to your web app
    driver.get("https://your-webapp.com")

    # Wait for page to load
    wait = WebDriverWait(driver, 10)

    # Find and click a button
    login_link = wait.until(
        EC.element_to_be_clickable((By.CSS_SELECTOR, "a.login-btn"))
    )
    login_link.click()

    # Fill in form
    email_input = wait.until(
        EC.presence_of_element_located((By.ID, "email"))
    )
    email_input.send_keys("test@example.com")

    password_input = driver.find_element(By.ID, "password")
    password_input.send_keys("testpassword")

    # Submit form
    submit_btn = driver.find_element(By.CSS_SELECTOR, "button[type='submit']")
    submit_btn.click()

    # Verify redirect to dashboard
    wait.until(EC.url_contains("/dashboard"))
    assert "/dashboard" in driver.current_url

    print("Test PASSED: Safari login flow works correctly")

finally:
    driver.quit()

Test Selenium en Safari (JavaScript)

// npm install selenium-webdriver

const { Builder, By, until } = require('selenium-webdriver');

async function safariTest() {
    const driver = await new Builder()
        .forBrowser('safari')
        .build();

    try {
        await driver.get('https://your-webapp.com');

        // Click login
        const loginBtn = await driver.findElement(By.css('a.login-btn'));
        await loginBtn.click();

        // Fill form
        const email = await driver.findElement(By.id('email'));
        await email.sendKeys('test@example.com');

        const password = await driver.findElement(By.id('password'));
        await password.sendKeys('testpassword');

        // Submit
        const submit = await driver.findElement(
            By.css("button[type='submit']")
        );
        await submit.click();

        // Verify
        await driver.wait(until.urlContains('/dashboard'), 10000);
        const url = await driver.getCurrentUrl();
        console.assert(url.includes('/dashboard'));

        console.log('Test PASSED: Safari login flow works');
    } finally {
        await driver.quit();
    }
}

safariTest();

Ejecución Paralela de Tests

Ejecutar tests en paralelo reduce drásticamente el tiempo total de ejecución de tu suite de tests. El Mac Mini M4 Pro puede ejecutar cómodamente 4-6 instancias del Simulator simultáneamente.

Testing Paralelo con XCTest

# Enable parallel testing with xcodebuild
xcodebuild test \
  -workspace MyApp.xcworkspace \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 17' \
  -parallel-testing-enabled YES \
  -parallel-testing-worker-count 4 \
  -resultBundlePath ./TestResults/Parallel.xcresult

# Parallel testing across multiple device types
xcodebuild test \
  -workspace MyApp.xcworkspace \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 17' \
  -destination 'platform=iOS Simulator,name=iPhone 17e' \
  -destination 'platform=iOS Simulator,name=iPad Pro 13-inch (M5)' \
  -parallel-testing-enabled YES \
  -resultBundlePath ./TestResults/MultiDeviceParallel.xcresult

Gestión de Instancias del Simulator

# List all available simulators
xcrun simctl list devices available

# Create custom simulator instances for testing
# (without a runtime argument, simctl uses the newest iOS runtime)
xcrun simctl create "Test-iPhone-1" "iPhone 17"
xcrun simctl create "Test-iPhone-2" "iPhone 17"
xcrun simctl create "Test-iPhone-3" "iPhone 17"
xcrun simctl create "Test-iPhone-4" "iPhone 17"

# Boot multiple simulators
xcrun simctl boot "Test-iPhone-1"
xcrun simctl boot "Test-iPhone-2"
xcrun simctl boot "Test-iPhone-3"
xcrun simctl boot "Test-iPhone-4"

# Check booted simulators
xcrun simctl list devices booted

# Shut down all simulators
xcrun simctl shutdown all

# Delete all test simulators
xcrun simctl delete "Test-iPhone-1"
xcrun simctl delete "Test-iPhone-2"
xcrun simctl delete "Test-iPhone-3"
xcrun simctl delete "Test-iPhone-4"

Rendimiento del Testing Paralelo

Rendimiento del Testing Paralelo
200 Tests de UI Duración Mejora de Velocidad
1 Simulador (secuencial) 45 minutos Referencia
2 Simuladores (en paralelo) 24 minutos 1,9x más rápido
4 Simuladores (en paralelo) 13 minutos 3,5x más rápido
6 Simuladores (en paralelo) 10 minutos 4,5x más rápido

Nota: Resultados medidos en Mac Mini M4 Pro (14 núcleos, 24GB RAM). El número óptimo de Simuladores en paralelo depende de la complejidad de tus tests y los requisitos de memoria. Para la mayoría de las suites de tests de UI, 4 workers paralelos proporcionan el mejor equilibrio entre velocidad y estabilidad.

Integración CI/CD

Integra tus tests automatizados en tu pipeline CI/CD para ejecución automatizada de tests en cada push, pull request o intervalo programado.

Workflow de GitHub Actions para Testing Automatizado

# .github/workflows/ios-tests.yml
name: iOS Automated Tests

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]
  schedule:
    # Nightly regression tests at 2 AM UTC
    - cron: '0 2 * * *'

env:
  # Xcode for every job, no sudo needed
  # (preinstalled Xcode; for another version, use the path from xcodes installed)
  DEVELOPER_DIR: /Applications/Xcode.app/Contents/Developer

jobs:
  unit-tests:
    name: Unit Tests
    runs-on: self-hosted
    timeout-minutes: 30

    steps:
      - uses: actions/checkout@v7

      - name: Resolve dependencies
        run: |
          xcodebuild -resolvePackageDependencies \
            -workspace MyApp.xcworkspace \
            -scheme MyApp

      - name: Run unit tests
        run: |
          xcodebuild test \
            -workspace MyApp.xcworkspace \
            -scheme MyApp \
            -destination 'platform=iOS Simulator,name=iPhone 17,OS=latest' \
            -parallel-testing-enabled YES \
            -resultBundlePath ${{ runner.temp }}/UnitTests.xcresult

      - name: Upload test results
        if: always()
        uses: actions/upload-artifact@v7
        with:
          name: unit-test-results
          path: ${{ runner.temp }}/UnitTests.xcresult

  ui-tests:
    name: UI Tests
    runs-on: self-hosted
    timeout-minutes: 60
    needs: unit-tests

    steps:
      - uses: actions/checkout@v7

      - name: Boot simulators for parallel testing
        run: |
          xcrun simctl boot "iPhone 17" || true
          xcrun simctl boot "iPhone 17e" || true

      - name: Run UI tests in parallel
        run: |
          xcodebuild test \
            -workspace MyApp.xcworkspace \
            -scheme MyAppUITests \
            -destination 'platform=iOS Simulator,name=iPhone 17' \
            -destination 'platform=iOS Simulator,name=iPhone 17e' \
            -parallel-testing-enabled YES \
            -parallel-testing-worker-count 4 \
            -resultBundlePath ${{ runner.temp }}/UITests.xcresult

      - name: Upload test results
        if: always()
        uses: actions/upload-artifact@v7
        with:
          name: ui-test-results
          path: ${{ runner.temp }}/UITests.xcresult

      - name: Cleanup simulators
        if: always()
        run: xcrun simctl shutdown all

Ejecutar Tests de Appium en CI

# Add to your GitHub Actions workflow
      - name: Start Appium server
        run: |
          appium server --address 127.0.0.1 --port 4723 &
          sleep 5
          curl http://127.0.0.1:4723/status

      - name: Build app for testing
        run: |
          xcodebuild build-for-testing \
            -workspace MyApp.xcworkspace \
            -scheme MyApp \
            -destination 'generic/platform=iOS Simulator'

      - name: Run Appium tests
        run: |
          cd tests/appium
          pip install -r requirements.txt
          pytest test_login.py test_checkout.py \
            --junitxml=results.xml -v

      - name: Stop Appium server
        if: always()
        run: pkill -f appium || true

Informes de Tests

Genera y procesa informes de tests para rastrear tendencias de calidad e identificar rápidamente tests fallidos.

Trabajar con Paquetes xcresult

# Test results summary as JSON (Xcode 16 and later)
xcrun xcresulttool get test-results summary \
  --path ./TestResults.xcresult

# Results of every test, then the details of one of them
# (TEST_ID: an identifier printed by the tests command)
xcrun xcresulttool get test-results tests \
  --path ./TestResults.xcresult
xcrun xcresulttool get test-results test-details \
  --test-id "TEST_ID" \
  --path ./TestResults.xcresult

# Export all attachments (screenshots, logs)
xcrun xcresulttool export attachments \
  --path ./TestResults.xcresult \
  --output-path ./artifacts

# Merge multiple xcresult bundles
xcrun xcresulttool merge \
  ./UnitTests.xcresult \
  ./UITests.xcresult \
  --output-path ./MergedResults.xcresult

Convertir a JUnit XML

JUnit XML es el formato universal soportado por plataformas CI/CD, integraciones de Slack y paneles de tests.

# Option 1: write JUnit XML while the tests run (xcbeautify)
brew install xcbeautify
set -o pipefail && xcodebuild test \
  -workspace MyApp.xcworkspace \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 17' \
  -resultBundlePath ./TestResults/Tests.xcresult \
  | xcbeautify --report junit --report-path ./reports
# Writes ./reports/junit.xml

# Option 2: convert existing .xcresult bundles with fastlane's
# trainer action (path: the folder that holds them)
fastlane run trainer path:"./TestResults" output_directory:"./reports"

# The generated JUnit XML works with:
# - GitHub Actions test summaries
# - Jenkins Test Result plugin
# - GitLab CI test reporting
# - Slack notifications via CI integrations

Captura de Pantalla en Caso de Fallo

// In your XCUITest, add screenshot capture on failure:
// XCTestCase+Screenshots.swift

import XCTest

extension XCTestCase {
    override func tearDown() {
        if testRun?.hasSucceeded == false {
            let screenshot = XCUIScreen.main.screenshot()
            let attachment = XCTAttachment(screenshot: screenshot)
            attachment.name = "Failure-\(name)"
            attachment.lifetime = .keepAlways
            add(attachment)
        }
        super.tearDown()
    }
}

Mejores Prácticas

Aislamiento de Tests

Cada test debe ser independiente y no depender del estado de tests anteriores. Restablece el estado de la app antes de cada test.

// In your XCUITest setUp() method:
override func setUp() {
    super.setUp()
    continueAfterFailure = false

    let app = XCUIApplication()
    app.launchArguments = ["--uitesting", "--reset-state"]
    app.launchEnvironment = [
        "DISABLE_ANIMATIONS": "1",
        "UI_TEST_MODE": "true"
    ]
    app.launch()
}

Gestión de Simuladores

Limpia los simuladores entre ejecuciones de tests para prevenir fugas de estado y problemas de espacio en disco.

#!/bin/bash
# cleanup-simulators.sh - Run before and after test suites

# Shutdown all running simulators
xcrun simctl shutdown all

# Erase all simulator content and settings
xcrun simctl erase all

# Delete unavailable simulators
xcrun simctl delete unavailable

# Clear DerivedData
rm -rf ~/Library/Developer/Xcode/DerivedData/*

# Clear simulator logs
rm -rf ~/Library/Logs/CoreSimulator/*

echo "Simulator cleanup complete"

Desactivar Animaciones para Mayor Velocidad

Desactiva las animaciones en tu app durante los tests de UI para reducir el tiempo de ejecución de tests y la inestabilidad.

// In your AppDelegate or App struct:
#if DEBUG
if CommandLine.arguments.contains("--uitesting") {
    UIView.setAnimationsEnabled(false)
}
#endif

Reintentar Tests Inestables

Usa el mecanismo de reintento de tests integrado de Xcode para manejar tests de UI ocasionalmente inestables.

# Run each failing test up to 3 times in total
xcodebuild test \
  -workspace MyApp.xcworkspace \
  -scheme MyAppUITests \
  -destination 'platform=iOS Simulator,name=iPhone 17' \
  -retry-tests-on-failure \
  -test-iterations 3 \
  -resultBundlePath ./TestResults.xcresult

Monitorizar Espacio en Disco

Los simuladores y artefactos de tests consumen espacio significativo en disco. Configura limpieza automatizada.

# Add to crontab for daily cleanup at midnight
# crontab -e
0 0 * * * /usr/local/bin/cleanup-test-artifacts.sh

# cleanup-test-artifacts.sh
#!/bin/bash
# Remove test results older than 7 days
find ~/TestResults -name "*.xcresult" -mtime +7 -delete

# Remove DerivedData older than 3 days
find ~/Library/Developer/Xcode/DerivedData \
  -maxdepth 1 -mtime +3 -exec rm -rf {} +

# Remove old simulator logs
find ~/Library/Logs/CoreSimulator -mtime +3 -delete

# Check remaining disk space
df -h / | tail -1

Preguntas Frecuentes

¿Cuántos simuladores en paralelo puede manejar un Mac Mini M4 Pro?
Con una CPU de 12 núcleos y 24GB de memoria, el Mac mini M4 Pro maneja cómodamente 4-6 instancias paralelas del iOS Simulator para testing de UI. Para tests unitarios solamente (sin GUI del Simulator), puedes ejecutar aún más workers paralelos. Recomendamos empezar con 4 e ir aumentando según los requisitos de memoria de tu suite de tests.
¿Puedo ejecutar tests sin interfaz gráfica sin VNC?
Sí. Los tests de XCTest y Appium se ejecutan completamente desde la línea de comandos a través de SSH. El iOS Simulator se ejecuta en modo "headless" cuando se lanza a través de xcodebuild sin una sesión de pantalla. No necesitas VNC conectado durante la ejecución de tests. VNC solo es útil para depurar tests fallidos visualmente.
¿Cómo manejo tests de UI inestables?
Primero, asegura el aislamiento de tests (restablece el estado de la app antes de cada test). Desactiva las animaciones. Usa esperas explícitas en lugar de sleep(). Usa el flag -retry-tests-on-failure de Xcode para reintentar automáticamente tests fallidos. En un servidor macOS dedicado, se elimina la inestabilidad por contención de recursos, que es la causa más común de tests inestables en máquinas CI compartidas.
¿Puedo hacer testing en dispositivos iOS reales desde un Mac remoto?
Sí. Redirige un iPhone o iPad físico desde tu ordenador al Mac con VirtualHere y aparecerá como un dispositivo conectado para Xcode, xcodebuild y Appium, así que puedes ejecutar tus tests en él. Para instalar compilaciones y hacer testing manual, usa TestFlight. Para matrices de dispositivos grandes, ejecuta tus suites de XCUITest o Appium en una nube de dispositivos reales como BrowserStack, AWS Device Farm o Sauce Labs. Ten en cuenta que Xcode Cloud de Apple solo ejecuta los tests en simuladores.
¿Qué pasa con el testing en diferentes versiones de iOS?
Puedes instalar múltiples runtimes del iOS Simulator en el mismo Mac. Usa xcodebuild -downloadPlatform iOS para la última versión, o descarga runtimes anteriores desde Xcode > Settings > Components. Luego especifica la versión del SO en el destino de tu test: -destination 'platform=iOS Simulator,name=iPhone 17,OS=26.0'.

Ejecuta Tu Suite de Tests 24/7

Obtén un Mac Mini M4 Pro dedicado para testing automatizado. Ejecución paralela, resultados consistentes y disponibilidad permanente.

Precios de My Remote Mac en USD, sin impuestos.

¿Buscas más detalles?

Explora la documentación completa: guías paso a paso, referencias de configuración y resolución de problemas.

Abrir la documentación →