Pruebas de UI
Descripción general
Espera condiciones, no tiempos de espera arbitrarios. Principio fundamental Las pruebas inestables provienen de adivinar cuánto tiempo tardan las operaciones. La espera basada en condiciones elimina las condiciones de carrera.
NUEVO en WWDC 2025: La grabación de automatización de UI te permite grabar interacciones, reproducirlas en diferentes dispositivos/idiomas y revisar grabaciones de vídeo de las ejecuciones de las pruebas.
Ejemplos de Prompts
Estas son preguntas reales que los desarrolladores hacen y para las que este skill está diseñado:
1. "Mis pruebas de UI pasan localmente en mi Mac pero fallan en CI. ¿Cómo las hago más fiables?"
→ El skill muestra patrones de espera basada en condiciones que funcionan en diferentes dispositivos/velocidades, eliminando las diferencias de temporización en CI.
2. "Mis pruebas usan sleep(2) y sleep(5) pero siguen siendo inestables. ¿Cómo reemplazo los tiempos de espera arbitrarios con condiciones reales?"
→ El skill demuestra patrones de waitForExistence, XCTestExpectation y sondeo (polling) para cargas de datos, solicitudes de red y animaciones.
3. "Acabo de grabar una prueba usando la grabación de automatización de UI de Xcode 26. ¿Cómo reviso el vídeo y depuro los fallos?"
→ El skill cubre los flujos de trabajo de depuración por vídeo para analizar las grabaciones y encontrar el paso exacto donde fallan las pruebas.
4. "Mi prueba falla en iPad pero pasa en iPhone. ¿Cómo escribo pruebas que funcionen en todos los tamaños de dispositivo?"
→ El skill explica estrategias de pruebas multifactor y predicados independientes del dispositivo para pruebas robustas entre dispositivos.
5. "Quiero escribir pruebas que no sean inestables. ¿Cuáles son los patrones críticos que necesito conocer?"
→ El skill proporciona plantillas de espera basada en condiciones, patrones centrados en accesibilidad y el árbol de decisiones para una arquitectura de pruebas fiable.
Señales de Alerta — Problemas de Fiabilidad en Pruebas
Si ves ALGUNA de estas, sospecha problemas de temporización:
- Las pruebas pasan localmente, fallan en CI (diferencias de temporización)
- Las pruebas a veces pasan, a veces fallan (condiciones de carrera)
- Las pruebas usan
sleep()oThread.sleep()(retrasos arbitrarios) - Las pruebas fallan con "Elemento de UI no encontrado" y luego pasan al reintentar
- Ejecuciones de pruebas largas (esperando los peores escenarios)
Árbol de Decisiones Rápido
¿La prueba falla?
├─ ¿Elemento no encontrado?
│ └─ Usa waitForExistence(timeout:) no sleep()
├─ ¿Pasa localmente, falla en CI?
│ └─ Reemplaza sleep() con sondeo de condiciones
├─ ¿La animación causa problemas?
│ └─ Espera a que la animación termine, no la deshabilites
└─ ¿Temporización de solicitud de red?
└─ Usa XCTestExpectation o waitForExistence
Patrón Principal: Espera Basada en Condiciones
❌ INCORRECTO (Tiempo de Espera Arbitrario):
func testButtonAppears() {
app.buttons["Login"].tap()
sleep(2) // ❌ Adivinando que tarda 2 segundos
XCTAssertTrue(app.buttons["Dashboard"].exists)
}
✅ CORRECTO (Esperar una Condición):
func testButtonAppears() {
app.buttons["Login"].tap()
let dashboard = app.buttons["Dashboard"]
XCTAssertTrue(dashboard.waitForExistence(timeout: 5))
}
Patrones Comunes de Pruebas de UI
Patrón 1: Esperar Elementos
// Esperar a que un elemento aparezca
func waitForElement(_ element: XCUIElement, timeout: TimeInterval = 5) -> Bool {
return element.waitForExistence(timeout: timeout)
}
// Uso
XCTAssertTrue(waitForElement(app.buttons["Submit"]))
Patrón 2: Esperar que un Elemento Desaparezca
func waitForElementToDisappear(_ element: XCUIElement, timeout: TimeInterval = 5) -> Bool {
let predicate = NSPredicate(format: "exists == false")
let expectation = XCTNSPredicateExpectation(predicate: predicate, object: element)
let result = XCTWaiter().wait(for: [expectation], timeout: timeout)
return result == .completed
}
// Uso
XCTAssertTrue(waitForElementToDisappear(app.activityIndicators["Loading"]))
Patrón 3: Esperar un Estado Específico
func waitForButton(_ button: XCUIElement, toBeEnabled enabled: Bool, timeout: TimeInterval = 5) -> Bool {
let predicate = NSPredicate(format: "isEnabled == %@", NSNumber(value: enabled))
let expectation = XCTNSPredicateExpectation(predicate: predicate, object: button)
let result = XCTWaiter().wait(for: [expectation], timeout: timeout)
return result == .completed
}
// Uso
let submitButton = app.buttons["Submit"]
XCTAssertTrue(waitForButton(submitButton, toBeEnabled: true))
submitButton.tap()
Patrón 4: Identificadores de Accesibilidad
Establecer en la app:
Button("Enviar") {
// acción
}
.accessibilityIdentifier("submitButton")
Usar en pruebas:
func testSubmitButton() {
let submitButton = app.buttons["submitButton"] // Usa el identificador, no la etiqueta
XCTAssertTrue(submitButton.waitForExistence(timeout: 5))
submitButton.tap()
}
Por qué: Los identificadores de accesibilidad no cambian con la localización y se mantienen estables ante actualizaciones de la UI.
Patrón 5: Retrasos por Solicitudes de Red
func testDataLoads() {
app.buttons["Refresh"].tap()
// Esperar a que el indicador de carga desaparezca
let loadingIndicator = app.activityIndicators["Loading"]
XCTAssertTrue(waitForElementToDisappear(loadingIndicator, timeout: 10))
// Ahora verificar que los datos se cargaron
XCTAssertTrue(app.cells.count > 0)
}
Patrón 6: Manejo de Animaciones
func testAnimatedTransition() {
app.buttons["Next"].tap()
// Esperar a que la vista de destino aparezca
let destinationView = app.otherElements["DestinationView"]
XCTAssertTrue(destinationView.waitForExistence(timeout: 2))
// Opcional: Esperar un poco más para que la animación se asiente
// Solo si es absolutamente necesario
RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.3))
}
Lista de Verificación para Pruebas
Antes de Escribir Pruebas
- Usa identificadores de accesibilidad para todos los elementos interactivos
- Evita etiquetas codificadas (usa identificadores en su lugar)
- Planifica los retrasos de red y las animaciones
- Elige tiempos de espera apropiados (2s UI, 10s red)
Al Escribir Pruebas
- Usa
waitForExistence()nosleep() - Usa predicados para condiciones complejas
- Prueba tanto caminos de éxito como de fallo
- Haz las pruebas independientes (pueden ejecutarse en cualquier orden)
Después de Escribir Pruebas
- Ejecuta las pruebas 10 veces localmente (detecta inestabilidad)
- Ejecuta las pruebas en el dispositivo soportado más lento
- Ejecuta las pruebas en el entorno de CI
- Revisa la duración de la prueba (si >30s por prueba, optimiza)
Consejos para Pruebas de UI en Xcode
Argumentos de Lanzamiento para Pruebas
func testExample() {
let app = XCUIApplication()
app.launchArguments = ["UI-Testing"]
app.launch()
}
En el código de la app:
if ProcessInfo.processInfo.arguments.contains("UI-Testing") {
// Usar datos simulados, omitir onboarding, etc.
}
Ejecución de Pruebas Más Rápida
override func setUpWithError() throws {
continueAfterFailure = false // Detenerse en el primer fallo
}
Depuración de Pruebas Fallidas
func testExample() {
// Tomar captura de pantalla al fallar
addUIInterruptionMonitor(withDescription: "Alerta") { alert in
alert.buttons["OK"].tap()
return true
}
// Imprimir la jerarquía de elementos
print(app.debugDescription)
}
Errores Comunes
❌ Usar sleep() para Todo
sleep(5) // ❌ Pierde tiempo si la operación se completa en 1s
❌ No Manejar Animaciones
app.buttons["Next"].tap()
XCTAssertTrue(app.buttons["Back"].exists) // ❌ Puede fallar durante la animación
❌ Etiquetas de Texto Codificadas
app.buttons["Submit"].tap() // ❌ Se rompe con la localización
❌ Pruebas Dependientes Entre Sí
// ❌ La prueba 2 asume que la prueba 1 se ejecutó primero
func test1_Login() { /* ... */ }
func test2_ViewDashboard() { /* asume que ha iniciado sesión */ }
❌ Sin Estrategia de Tiempo de Espera
element.waitForExistence(timeout: 100) // ❌ Demasiado largo
element.waitForExistence(timeout: 0.1) // ❌ Demasiado corto
Usa tiempos de espera apropiados:
- Animaciones de UI: 2-3 segundos
- Solicitudes de red: 10 segundos
- Operaciones complejas: 30 segundos como máximo
Impacto en el Mundo Real
Antes (usando sleep()):
- Suite de pruebas: 15 minutos (esperando el peor caso)
- Pruebas inestables: 20% de tasa de fallo
- Fallos en CI: 50% requieren reintento
Después (espera basada en condiciones):
- Suite de pruebas: 5 minutos (espera solo cuando es necesario)
- Pruebas inestables: <2% de tasa de fallo
- Fallos en CI: <5% requieren reintento
Conclusión clave Las pruebas terminan más rápido Y son más fiables cuando se esperan condiciones reales en lugar de adivinar tiempos.
Grabación de Automatización de UI
Descripción General
NUEVO en Xcode 26: Graba, reproduce y revisa pruebas de automatización de UI con grabaciones de vídeo.
Tres Fases:
- Grabar — Captura interacciones (toques, deslizamientos, pulsaciones de botones de hardware) como código Swift
- Reproducir — Ejecutar en múltiples dispositivos, idiomas, regiones, orientaciones
- Revisar — Ver grabaciones de vídeo, analizar fallos, ver superposiciones de elementos de UI
Plataformas Soportadas: iOS, iPadOS, macOS, watchOS, tvOS, axiom-visionOS (Diseñado para iPad)
Cómo Funciona la Automatización de UI
Principios Clave:
- La automatización de UI interactúa con tu app como lo haría una persona usando gestos y eventos de hardware
- Se ejecuta completamente independiente de tu app (los modelos/datos de la app no son directamente accesibles)
- Utiliza el marco de accesibilidad como tecnología subyacente
- Le dice al SO qué gestos realizar, luego espera a que se completen de forma síncrona, uno a la vez
Las acciones incluyen:
- Lanzar tu app
- Interactuar con botones y navegación
- Establecer el estado del sistema (Modo Oscuro, axiom-localization, etc.)
- Establecer una ubicación simulada
La Accesibilidad es la Base
Comprensión Crítica: La accesibilidad proporciona información directamente a la automatización de UI.
Lo que la accesibilidad ve:
- Tipos de elementos (botón, texto, imagen, etc.)
- Etiquetas (texto visible)
- Valores (estado actual para casillas de verificación, etc.)
- Marcos (posiciones de los elementos)
- Identificadores (identificadores de accesibilidad — NO localizados)
Mejor Práctica: Una gran experiencia de accesibilidad = una gran experiencia de automatización de UI.
Preparando tu App para la Grabación
Paso 1: Agregar Identificadores de Accesibilidad
SwiftUI:
Button("Enviar") {
// acción
}
.accessibilityIdentifier("submitButton")
// Haz los identificadores específicos para cada instancia
List(landmarks) { landmark in
LandmarkRow(landmark)
.accessibilityIdentifier("landmark-\(landmark.id)")
}
UIKit:
let button = UIButton()
button.accessibilityIdentifier = "submitButton"
// Usa índice para celdas de tabla
cell.accessibilityIdentifier = "cell-\(indexPath.row)"
Los buenos identificadores son:
- ✅ Únicos dentro de toda la app
- ✅ Descriptivos del contenido del elemento
- ✅ Estáticos (no reaccionan a cambios de contenido)
- ✅ No localizados (iguales en todos los idiomas)
Por qué importan los identificadores:
- Los títulos/descripciones pueden cambiar, los identificadores permanecen estables
- Funcionan con cadenas localizadas
- Identifican de forma única elementos con contenido dinámico
Consejo Profesional: Usa el asistente de codificación de Xcode para agregar identificadores:
Prompt: "Agrega identificadores de accesibilidad a las partes relevantes de esta vista"
Paso 2: Revisar la Accesibilidad con Accessibility Inspector
Iniciar Accessibility Inspector:
- Menú Xcode → Abrir Developer Tool → Accessibility Inspector
- O: Iniciar desde Spotlight
Características:
- Inspector de Elementos — Lista los valores de accesibilidad para cualquier vista
- Detalles de la propiedad — Haz clic en el nombre de la propiedad para obtener documentación
- Soporte de plataforma — Funciona en todas las plataformas Apple
Qué verificar:
- Los elementos tienen etiquetas
- Los elementos interactivos tienen tipos (botón, no solo texto)
- Los valores están establecidos para elementos con estado (casillas de verificación, conmutadores)
- Los identificadores están establecidos para elementos con contenido dinámico/localizado
Referencia de Código de Muestra: Ofrecer una experiencia de accesibilidad excepcional
Paso 3: Agregar un Target de Pruebas de UI
- Abre la configuración del proyecto en Xcode
- Haz clic en "+" debajo de la lista de targets
- Selecciona UI Testing Bundle
- Haz clic en Finalizar
Resultado: Se agrega una nueva carpeta de pruebas de UI con pruebas de plantilla al proyecto.
Grabando Interacciones
Iniciar una Grabación (Xcode 26)
- Abre el archivo fuente de la prueba de UI
- Aparece un popover explicando cómo iniciar la grabación (solo la primera vez)
- Haz clic en el botón "Start Recording" en el margen del editor
- Xcode compila e inicia la app en el Simulador/dispositivo
Durante la Grabación:
- Interactúa con la app normalmente (toques, deslizamientos, entrada de texto, etc.)
- El código que representa las interacciones aparece en el editor de código fuente en tiempo real
- La grabación se actualiza mientras escribes (por ejemplo, entradas en campos de texto)
Detener la Grabación:
- Haz clic en el botón "Stop Run" en Xcode
Ejemplo de Sesión de Grabación
func testCreateAustralianCollection() {
let app = XCUIApplication()
app.launch()
// Tocar la pestaña "Collections" (grabado automáticamente)
app.tabBars.buttons["Collections"].tap()
// Tocar "+" para agregar nueva colección
app.navigationBars.buttons["Add"].tap()
// Tocar el botón "Edit"
app.buttons["Edit"].tap()
// Escribir nombre de la colección
app.textFields.firstMatch.tap()
app.textFields.firstMatch.typeText("Max's Australian Adventure")
// Tocar "Edit Landmarks"
app.buttons["Edit Landmarks"].tap()
// Agregar lugares emblemáticos
app.tables.cells.containing(.staticText, identifier:"Great Barrier Reef").buttons["Add"].tap()
app.tables.cells.containing(.staticText, identifier:"Uluru").buttons["Add"].tap()
// Tocar la marca de verificación para guardar
app.navigationBars.buttons["Done"].tap()
}
Revisando el Código Grabado
Después de grabar, revisa y ajusta las consultas:
Múltiples Opciones: Cada línea tiene un menú desplegable que muestra formas alternativas de abordar el elemento.
Recomendaciones de Selección:
- Para cadenas localizadas (texto, etiquetas de botones): Elige el identificador de accesibilidad si está disponible
- Para vistas profundamente anidadas: Elige la consulta más corta (se mantiene resistente a medida que la app cambia)
- Para contenido dinámico (marcas de tiempo, temperatura): Usa una consulta genérica o identificador
Ejemplo:
// Opciones grabadas para un campo de texto:
app.textFields["Collection Name"] // ❌ Se rompe si la etiqueta se localiza
app.textFields["collectionNameField"] // ✅ Usa el identificador
app.textFields.element(boundBy: 0) // ✅ Basado en posición
app.textFields.firstMatch // ✅ Genérico, el más corto
Reproduciendo y Verificando Resultados
Requisitos Mínimos: Un destino y esquema que ejecute las pruebas.
Proceso de Reproducción:
- La automatización de UI reproduce la secuencia completa de acciones grabadas
- Puedes introducir afirmaciones (assertions) para verificar que el estado del modelo y la UI son correctos
- Importante: Las reproducciones se limitan a acciones y UI. Las comprobaciones de estado del modelo deben hacerse con afirmaciones
Opciones de Reproducción:
- Ejecutar en múltiples dispositivos/simuladores: Para verificar la capacidad de respuesta de la UI
- Cambiar el idioma/región: Para verificar localizaciones
- Orientación: Para verificar rotaciones
Agregar Afirmaciones
func testCreateAustralianCollection() {
let app = XCUIApplication()
app.launch()
// Interacciones grabadas...
app.tabBars.buttons["Collections"].tap()
app.navigationBars.buttons["Add"].tap()
app.buttons["Edit"].tap()
app.textFields.firstMatch.tap()
app.textFields.firstMatch.typeText("Max's Australian Adventure")
app.buttons["Edit Landmarks"].tap()
app.tables.cells.containing(.staticText, identifier:"Great Barrier Reef").buttons["Add"].tap()
app.tables.cells.containing(.staticText, identifier:"Uluru").buttons["Add"].tap()
app.navigationBars.buttons["Done"].tap()
// Afirmación de la UI: Las colecciones deben aparecer
let collections = app.tables.cells
let newCollection = collections.staticTexts["Max's Australian Adventure"]
XCTAssertTrue(newCollection.waitForExistence(timeout: 5))
XCTAssertEqual(collections.count, 1) // asumiendo que empezó vacío
// Afirmación del modelo: Verificar datos de la colección
// Nota: Usar APIs del modelo directamente, no a través de UI
let collection = Collection(name: "Max's Australian Adventure")
// Asume que la app tiene una API para obtener la colección (setup de prueba necesario)
// XCTAssertEqual(collection.landmarks.count, 2)
}
Revisando Fallos con Vídeo
Cuando falla una reproducción, la revisión de vídeo es una herramienta de depuración clave:
Cómo revisar el vídeo:
- El Resultado de la Prueba (Test Result) incluye un enlace a la grabación de vídeo del fallo
- Haz clic en el enlace para ver la grabación
- El vídeo se reproduce automáticamente desde el inicio de la ejecución de la prueba
- Ver la línea de tiempo del vídeo: Marcada para mostrar la interacción actual y el resultado de la afirmación
- La UI del reproductor de vídeo muestra iconos para cada paso de la prueba junto con el código
Superposiciones:
- Para cada acción de prueba, la UI está resaltada con superposiciones para ayudar a ver exactamente en qué elemento se estaba operando
- Si la afirmación falla, el vídeo puede mostrar la UI en el momento del fallo, permitiéndote ver qué se mostró realmente
Comparar con Capturas de Pantalla:
- Las capturas de pantalla de la UI se generan automáticamente para cada ejecución de prueba
- Esta información combinada ayuda a aislar problemas
Consejos de Depuración
Problemas Comunes
| Problema | Síntoma | Solución |
|---|---|---|
| Identificador no encontrado | No matches found | Verifica que el identificador existe en la jerarquía de accesibilidad |
| Múltiples coincidencias | Found multiple matches | Hace que la consulta sea más específica o única |
| Elemento no hittable (tocable) | Elemento existe pero no se puede tocar | Espera a que la animación termine o desplázate al elemento |
| La reproducción falla en otro dispositivo | La prueba pasa en un dispositivo pero falla en otro | Usa tiempo de espera basado en condiciones, no tiempos fijos |
| Fallo de localización | La prueba falla al cambiar el idioma | Usa identificadores de accesibilidad en lugar de etiquetas de texto |
Estados de la Aplicación
Simular configuraciones del sistema:
app.launchArguments = ["UI-Testing"]
// Configurar para la prueba
app.launchEnvironment = [
"AXIM_LOCALE": "en",
"AXIM_ORIENTATION": "portrait",
"AXIM_DARK_MODE": "true"
]
app.launch()
Nota: No es necesario para la reproducción, pero puedes usarlo para probar diferentes configuraciones desde el código.
Resumen
Conclusiones Clave
- Usa espera basada en condiciones — Reemplaza
sleep()conwaitForExistence(),XCTestExpectationo predicados - Usa identificadores de accesibilidad — Son estables, no localizados y hacen que las pruebas sean más fiables
- Prueba en múltiples dispositivos — Ejecuta en al menos un dispositivo simulado y uno real, y en diferentes tamaños
- Piensa en la accesibilidad primero — Una buena accesibilidad lleva a una mejor automatización de pruebas
- Usa la grabación de vídeo — Revisa los fallos viendo la grabación de la reproducción para encontrar el paso exacto
Comprobación Rápida
- ¿Todas las interacciones esperan condiciones? (no se usa
sleep()) - ¿Los elementos interactivos tienen identificadores de accesibilidad únicos?
- ¿Las pruebas se ejecutan de forma fiable en diferentes dispositivos e idiomas?
- ¿Las pruebas se ejecutan en menos de 30 segundos cada una?
- ¿Menos del 5% de las ejecuciones fallan?