O que Testes de UI faz?
Visão Geral
Aguarde por condições, não por timeouts arbitrários. Princípio central Testes instáveis surgem de adivinhar quanto tempo as operações levam. A espera baseada em condições elimina condições de corrida.
NOVO na WWDC 2025: A Gravação de Automação de UI permite gravar interações, reproduzir em vários dispositivos/idiomas e revisar gravações em vídeo das execuções de teste.
Exemplos de Prompts
Estas são perguntas reais que desenvolvedores fazem e que este skill foi projetado para responder:
1. "Meus testes de UI passam localmente no meu Mac, mas falham no CI. Como torná-los mais confiáveis?"
→ O skill mostra padrões de espera baseados em condições que funcionam em vários dispositivos/velocidades, eliminando diferenças de tempo no CI
2. "Meus testes usam sleep(2) e sleep(5), mas ainda são instáveis. Como substituir timeouts arbitrários por condições reais?"
→ O skill demonstra waitForExistence, XCTestExpectation e padrões de polling para carregamento de dados, requisições de rede e animações
3. "Acabei de gravar um teste usando a Gravação de Automação de UI do Xcode 26. Como revisar o vídeo e depurar falhas?"
→ O skill aborda fluxos de trabalho de Depuração por Vídeo para analisar gravações e encontrar a etapa exata onde os testes falham
4. "Meu teste está falhando no iPad, mas passando no iPhone. Como escrever testes que funcionem em todos os tamanhos de dispositivo?"
→ O skill explica estratégias de teste multifatorial e predicados independentes de dispositivo para testes robustos entre dispositivos
5. "Quero escrever testes que não sejam instáveis. Quais são os padrões críticos que preciso conhecer?"
→ Oskill fornece modelos de espera baseados em condições, padrões de acessibilidade em primeiro lugar e a árvore de decisão para uma arquitetura de teste confiável
Bandeiras Vermelhas — Problemas de Confiabilidade do Teste
Se você vir QUALQUER um destes, suspeite de problemas de tempo:
- Testes passam localmente, falham no CI (diferenças de tempo)
- Testes às vezes passam, às vezes falham (condições de corrida)
- Testes usam
sleep()ouThread.sleep()(atrasos arbitrários) - Testes falham com "elemento de UI não encontrado" e depois passam na repetição
- Execuções de teste longas (esperando pelos piores cenários)
Árvore de Decisão Rápida
Teste falhando?
├─ Elemento não encontrado?
│ └─ Use waitForExistence(timeout:) não sleep()
├─ Passa localmente, falha no CI?
│ └─ Substitua sleep() por polling de condição
├─ Animação causando problemas?
│ └─ Aguarde a conclusão da animação, não a desabilite
└─ Tempo de requisição de rede?
└─ Use XCTestExpectation ou waitForExistence
Padrão Central: Espera Baseada em Condições
❌ ERRADO (Timeout Arbitrário):
func testButtonAppears() {
app.buttons["Login"].tap()
sleep(2) // ❌ Adivinhando que leva 2 segundos
XCTAssertTrue(app.buttons["Dashboard"].exists)
}
✅ CORRETO (Aguardar Condição):
func testButtonAppears() {
app.buttons["Login"].tap()
let dashboard = app.buttons["Dashboard"]
XCTAssertTrue(dashboard.waitForExistence(timeout: 5))
}
Padrões Comuns de Teste de UI
Padrão 1: Aguardando Elementos
// Aguarda o elemento aparecer
func waitForElement(_ element: XCUIElement, timeout: TimeInterval = 5) -> Bool {
return element.waitForExistence(timeout: timeout)
}
// Uso
XCTAssertTrue(waitForElement(app.buttons["Submit"]))
Padrão 2: Aguardando o Elemento Desaparecer
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"]))
Padrão 3: Aguardando um 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()
Padrão 4: Identificadores de Acessibilidade
Definir no aplicativo:
Button("Submit") {
// ação
}
.accessibilityIdentifier("submitButton")
Usar nos testes:
func testSubmitButton() {
let submitButton = app.buttons["submitButton"] // Usa identificador, não rótulo
XCTAssertTrue(submitButton.waitForExistence(timeout: 5))
submitButton.tap()
}
Por quê: Identificadores de acessibilidade não mudam com localização, permanecem estáveis em atualizações de UI.
Padrão 5: Atrasos de Requisição de Rede
func testDataLoads() {
app.buttons["Refresh"].tap()
// Aguarda o indicador de carregamento desaparecer
let loadingIndicator = app.activityIndicators["Loading"]
XCTAssertTrue(waitForElementToDisappear(loadingIndicator, timeout: 10))
// Agora verifica se os dados foram carregados
XCTAssertTrue(app.cells.count > 0)
}
Padrão 6: Manipulação de Animação
func testAnimatedTransition() {
app.buttons["Next"].tap()
// Aguarda a visualização de destino aparecer
let destinationView = app.otherElements["DestinationView"]
XCTAssertTrue(destinationView.waitForExistence(timeout: 2))
// Opcional: Aguarda um pouco mais para a animação se estabilizar
// Apenas se absolutamente necessário
RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.3))
}
Checklist de Teste
Antes de Escrever Testes
- Use identificadores de acessibilidade para todos os elementos interativos
- Evite rótulos codificados (use identificadores)
- Planeje atrasos de rede e animações
- Escolha timeouts apropriados (2s para UI, 10s para rede)
Ao Escrever Testes
- Use
waitForExistence()nãosleep() - Use predicados para condições complexas
- Teste caminhos de sucesso e falha
- Torne os testes independentes (podem executar em qualquer ordem)
Depois de Escrever Testes
- Execute os testes 10 vezes localmente (detectar instabilidade)
- Execute os testes no dispositivo compatível mais lento
- Execute os testes no ambiente de CI
- Verifique a duração do teste (se >30s por teste, otimize)
Dicas de Teste de UI do Xcode
Argumentos de Inicialização para Teste
func testExample() {
let app = XCUIApplication()
app.launchArguments = ["UI-Testing"]
app.launch()
}
No código do aplicativo:
if ProcessInfo.processInfo.arguments.contains("UI-Testing") {
// Usar dados mock, pular onboarding, etc.
}
Execução de Teste Mais Rápida
override func setUpWithError() throws {
continueAfterFailure = false // Parar no primeiro erro
}
Depurando Testes com Falha
func testExample() {
// Tirar screenshot na falha
addUIInterruptionMonitor(withDescription: "Alert") { alert in
alert.buttons["OK"].tap()
return true
}
// Imprimir hierarquia de elementos
print(app.debugDescription)
}
Erros Comuns
❌ Usando sleep() para Tudo
sleep(5) // ❌ Perde tempo se a operação for concluída em 1s
❌ Não Manipulando Animações
app.buttons["Next"].tap()
XCTAssertTrue(app.buttons["Back"].exists) // ❌ Pode falhar durante a animação
❌ Rótulos de Texto Codificados
app.buttons["Submit"].tap() // ❌ Quebra com localização
❌ Testes Dependentes Uns dos Outros
// ❌ O Teste 2 assume que o Teste 1 foi executado primeiro
func test1_Login() { /* ... */ }
func test2_ViewDashboard() { /* assume que está logado */ }
❌ Sem Estratégia de Timeout
element.waitForExistence(timeout: 100) // ❌ Muito longo
element.waitForExistence(timeout: 0.1) // ❌ Muito curto
Use timeouts apropriados:
- Animações de UI: 2-3 segundos
- Requisições de rede: 10 segundos
- Operações complexas: 30 segundos no máximo
Impacto no Mundo Real
Antes (usando sleep()):
- Suite de teste: 15 minutos (esperando pelo pior caso)
- Testes instáveis: 20% de taxa de falha
- Falhas de CI: 50% exigem repetição
Depois (espera baseada em condições):
- Suite de teste: 5 minutos (espera apenas quando necessário)
- Testes instáveis: <2% de taxa de falha
- Falhas de CI: <5% exigem repetição
Insight chave Os testes terminam MAIS RÁPIDO E são mais confiáveis quando aguardam condições reais em vez de adivinhar tempos.
Gravação de Automação de UI
Visão Geral
NOVO no Xcode 26: Grave, reproduza e revise testes de automação de UI com gravações em vídeo.
Três Fases:
- Gravar — Capture interações (toques, deslizes, pressionamentos de botão de hardware) como código Swift
- Reproduzir — Execute em vários dispositivos, idiomas, regiões, orientações
- Revisar — Assista às gravações em vídeo, analise falhas, visualize sobreposições de elementos de UI
Plataformas Suportadas: iOS, iPadOS, macOS, watchOS, tvOS, axiom-visionOS (Projetado para iPad)
Como a Automação de UI Funciona
Princípios Chave:
- A automação de UI interage com seu aplicativo como uma pessoa faria usando gestos e eventos de hardware
- Executa completamente independente do seu aplicativo (modelos/dados do aplicativo não acessíveis diretamente)
- Usa a estrutura de acessibilidade como tecnologia subjacente
- Diz ao SO quais gestos executar, depois aguarda a conclusão sincronicamente, um por vez
Ações incluem:
- Iniciar seu aplicativo
- Interagir com botões e navegação
- Definir estado do sistema (Modo Escuro, axiom-localization, etc.)
- Definir localização simulada
Acessibilidade é a Base
Entendimento Crítico: A acessibilidade fornece informações diretamente à automação de UI.
O que a acessibilidade vê:
- Tipos de elemento (botão, texto, imagem, etc.)
- Rótulos (texto visível)
- Valores (estado atual para caixas de seleção, etc.)
- Quadros (posições do elemento)
- Identificadores (identificadores de acessibilidade — NÃO localizados)
Melhor Prática: Ótima experiência de acessibilidade = ótima experiência de automação de UI.
Preparando Seu Aplicativo para Gravação
Passo 1: Adicione Identificadores de Acessibilidade
SwiftUI:
Button("Submit") {
// ação
}
.accessibilityIdentifier("submitButton")
// Torne os identificadores específicos para a instância
List(landmarks) { landmark in
LandmarkRow(landmark)
.accessibilityIdentifier("landmark-\(landmark.id)")
}
UIKit:
let button = UIButton()
button.accessibilityIdentifier = "submitButton"
// Use índice para células de tabela
cell.accessibilityIdentifier = "cell-\(indexPath.row)"
Identificadores bons são:
- ✅ Únicos em todo o aplicativo
- ✅ Descritivos do conteúdo do elemento
- ✅ Estáticos (não reagem a mudanças de conteúdo)
- ✅ Não localizados (iguais em todos os idiomas)
Por que os identificadores importam:
- Títulos/descrições podem mudar, os identificadores permanecem estáveis
- Funcionam em strings localizadas
- Identificam exclusivamente elementos com conteúdo dinâmico
Dica Profissional: Use o assistente de codificação do Xcode para adicionar identificadores:
Prompt: "Adicione identificadores de acessibilidade às partes relevantes desta visualização"
Passo 2: Revise a Acessibilidade com o Inspetor de Acessibilidade
Inicie o Inspetor de Acessibilidade:
- Menu do Xcode → Open Developer Tool → Accessibility Inspector
- Ou: Inicie pelo Spotlight
Recursos:
- Element Inspector — Lista valores de acessibilidade para qualquer visualização
- Property details — Clique no nome da propriedade para documentação
- Platform support — Funciona em todas as plataformas Apple
O que verificar:
- Os elementos têm rótulos
- Os elementos interativos têm tipos (botão, não apenas texto)
- Valores definidos para elementos com estado (caixas de seleção, alternadores)
- Identificadores definidos para elementos com conteúdo dinâmico/localizado
Referência de Código de Exemplo: Delivering an exceptional accessibility experience
Passo 3: Adicione um Alvo de Teste de UI
- Abra as configurações do projeto no Xcode
- Clique em "+" abaixo da lista de alvos
- Selecione UI Testing Bundle
- Clique em Finish
Resultado: Nova pasta de teste de UI com testes de modelo adicionados ao projeto.
Gravando Interações
Iniciando uma Gravação (Xcode 26)
- Abra o arquivo de origem do teste de UI
- Um popover aparece explicando como iniciar a gravação (apenas na primeira vez)
- Clique no botão "Start Recording" na margem do editor
- O Xcode compila e inicia o aplicativo no Simulador/dispositivo
Durante a Gravação:
- Interaja com o aplicativo normalmente (toques, deslizes, entrada de texto, etc.)
- O código representando as interações aparece no editor de origem em tempo real
- A gravação é atualizada conforme você digita (por exemplo, entradas em campos de texto)
Parando a Gravação:
- Clique no botão "Stop Run" no Xcode
Exemplo de Sessão de Gravação
func testCreateAustralianCollection() {
let app = XCUIApplication()
app.launch()
// Tocar na aba "Collections" (gravado automaticamente)
app.tabBars.buttons["Collections"].tap()
// Tocar em "+" para adicionar nova coleção
app.navigationBars.buttons["Add"].tap()
// Tocar no botão "Edit"
app.buttons["Edit"].tap()
// Digitar o nome da coleção
app.textFields.firstMatch.tap()
app.textFields.firstMatch.typeText("Max's Australian Adventure")
// Tocar em "Edit Landmarks"
app.buttons["Edit Landmarks"].tap()
// Adicionar landmarks
app.tables.cells.containing(.staticText, identifier:"Great Barrier Reef").buttons["Add"].tap()
app.tables.cells.containing(.staticText, identifier:"Uluru").buttons["Add"].tap()
// Tocar na marca de seleção para salvar
app.navigationBars.buttons["Done"].tap()
}
Revisando o Código Gravado
Após a gravação, revise e ajuste as consultas:
Múltiplas Opções: Cada linha tem um menu suspenso mostrando maneiras alternativas de endereçar o elemento.
Recomendações de Seleção:
- Para strings localizadas (texto, rótulos de botão): Escolha o identificador de acessibilidade se disponível
- Para visualizações aninhadas profundamente: Escolha a consulta mais curta (permanece resiliente à medida que o aplicativo muda)
- Para conteúdo dinâmico (carimbos de data/hora, temperatura): Use consulta genérica ou identificador
Exemplo:
// Opções gravadas para o campo de texto:
app.textFields["Collection Name"] // ❌ Quebra se o rótulo for localizado
app.textFields["collectionNameField"] // ✅ Usa identificador
app.textFields.element(boundBy: 0) // ✅ Baseado em posição
app.textFields.firstMatch // ✅ Genérico, mais curto
Reproduzindo Testes em Vários Dispositivos e Idiomas
Benefícios da Reprodução Automatizada
Ganho Principal: Um teste gravado pode ser executado em muitos dispositivos e configurações.
O que muda entre execuções:
- Dispositivo (iPhone, iPad, Apple Watch, etc.)
- Idioma do sistema
- Região
- Orientação (retrato, paisagem)
- Modo de exibição (Axiom se aplicável)
O que permanece igual:
- As interações gravadas
- As verificações nos testes
- Os identificadores de acessibilidade
Como Funciona a Reprodução
O esquema de teste no Xcode define destinos de execução:
Destinos únicos vs. múltiplos:
Único Destino:
- Abra o esquema para seu alvo de teste
- Selecione um destino específico (ex: "My iPhone")
- Execute o teste
Múltiplos Destinos:
- Abra o esquema para seu alvo de teste
- Selecione "Múltiplos Destinos"
- Escolha os destinos (dispositivos/simuladores)
- O Xcode executa o teste em cada destino sequencialmente
Configuração:
- Product → Scheme → Edit Scheme
- Navegue para Test → Info
- Adicione destinos na seção "Destinos"
Revisando Gravações de Teste com Vídeo
Acessando Gravações
- Execute testes de UI com vídeo
- Abra o Report Navigator (última aba no Navigator do Xcode)
- Selecione uma execução de teste — os vídeos são listados na seção Recording
Componentes da Gravação:
- Tela do dispositivo em escala — tela cheia redimensionável com toques sobrepostos
- Trilha do tempo — linha do tempo com marcadores para cada interação e ação de teste
- Sobreposições de UI (opcional) — quadros e rótulos para elementos de acessibilidade à medida que aparecem
- Ações — etapas gravadas lado a lado com a linha do tempo
Navegando nas Gravações
Navegação Básica:
- Barra de espaço: Alternar reprodução/pausa
- Setas para a esquerda/direita: Avançar/retroceder um quadro
- Clique e arraste: Navegar na trilha do tempo
Filtragem:
- Botão Issue Only: Mostrar apenas ações que resultaram em problemas
- Botão Show/Hide Overlays: Alternar sobreposições de acessibilidade
Análise de Falhas
Foco principal: A vista de vídeo move-se automaticamente para o ponto de falha na linha do tempo.
Ações de depuração:
- Verifique o layout do elemento no momento da falha
- Verifique se sobreposições mostram elementos de acessibilidade corretos
- Navegue manualmente pelas ações antes da falha
- Compare com execuções bem-sucedidas para encontrar a diferença
Práticas Recomendadas
Para Gravação
- Prepare identificadores de acessibilidade primeiro — identifique elementos que serão endereçados
- Revise código gravado — otimize consultas, adicione verificações
- Adicione verificações explícitas — após gravar ações, adicione verificações para estados esperados
- Execute em múltiplos idiomas — garanta que funcione globalmente
- Não grave excessivamente — grave seções focadas, não fluxos inteiros de uma vez
Para Reprodução
- Use identificador, não string localizada — chaves para testes entre idiomas
- Teste em configurações representativas — inclua dispositivo mais lento, diferentes orientações
- Revise gravações de falha — o vídeo mostra exatamente o que aconteceu
- Monitore a duração do teste — gravações de vídeo adicionam tempo de execução
Boa Higiene de Acessibilidade
- A boa acessibilidade é boa para testes de UI
- Use Accessibility Inspector para verificar elementos
- Identificadores devem ser estáveis, descritivos e não localizados
- Elementos interativos devem ter tipos de acessibilidade
Próximos Passos
- Adicione identificadores de acessibilidade ao seu aplicativo
- Adicione testes de UI com espera baseada em condições
- Substitua sleep() existentes por waitForExistence
- Execute testes em vários dispositivos e idiomas
- Revise gravações para diagnosticar falhas
- Itere — refine identificadores e consultas para robustez
Lembre-se do princípio central: Aguarde condições, não timeouts arbitrários. Isso torna os testes mais rápidos E mais confiáveis.