XCUITest: o que é, como funciona e teste de UI iOS

O que é XCUITest

XCUITest é um framework de teste de UI lançado pela Apple no Xcode 7 (2015). Ele substituiu o UI Automation (UIA) e se tornou a ferramenta padrão para teste automatizado de interface nas plataformas Apple. O XCUITest está totalmente integrado ao XCTest — o framework de teste unificado da Apple.

Diferença dos testes unitários do XCTest

Ao contrário dos testes unitários, que verificam a lógica no nível de classes e métodos, o XCUITest testa a interface do usuário através da simulação de ações. Os testes são executados em um processo separado do aplicativo e interagem com ele através da API de Acessibilidade — isso garante isolamento e confiabilidade.

Vantagens da abordagem nativa

O XCUITest não requer instalação de servidores de terceiros (ao contrário do Appium) ou bibliotecas adicionais para interação com o dispositivo. Tudo o que é necessário já está incluído no Xcode. Isso garante a melhor compatibilidade com novas versões do iOS e acesso instantâneo a novos gestos e controles.

Arquitetura do XCUITest e XCTest

A arquitetura do XCUITest é construída em duas classes principais: XCUIApplication — o aplicativo em teste iniciado, e XCUIElement — o elemento de interface. O executor de testes XCTest gerencia o ciclo de vida dos testes: setUp, métodos de teste, tearDown. O XCUITest é executado como um processo separado que controla o aplicativo através da ponte de acessibilidade.

Hierarquia de elementos

Cada elemento da UI é representado por um objeto XCUIElement, que contém métodos para consultar o estado (exists, isHittable, label, value) e ações (tap, pressForDuration, swipeUp, typeText). Os elementos são organizados em uma hierarquia através de cadeias de consulta: app.buttons[].staticTexts[].tables[]. Isso permite encontrar qualquer elemento na tela de forma flexível.

Acessibilidade e localizadores

O XCUITest utiliza atributos de acessibilidade para identificar elementos: accessibilityIdentifier — um identificador programático, e accessibilityLabel — uma descrição para o VoiceOver. Recomenda-se definir accessibilityIdentifier no código do aplicativo — isso torna os testes estáveis independentemente da localização e layout.

Escrevendo testes de UI com XCUITest

Os testes do XCUITest são escritos em Swift usando a sintaxe do XCTest. Cada classe de teste herda de XCTestCase e contém métodos que começam com test. No método setUp, o aplicativo é iniciado com a configuração necessária, e no tearDown, é realizada a limpeza e o encerramento da sessão.

Cenário básico de teste

Um teste típico: encontrar um elemento → executar uma ação → verificar o resultado. A busca de elementos é feita através de consultas filhas do XCUIElementQuery: app.buttons["loginButton"], app.textFields["email"]. Ações: .tap(), .typeText("text"), .swipeUp(). Verificações: XCTAssertTrue(element.exists) ou XCTAssertEqual(element.label, "expected").

import XCTest

class LoginTests: XCTestCase {
    let app = XCUIApplication()

    override func setUp() {
        continueAfterFailure = false
        app.launch()
    }

    func testLoginWithValidCredentials() {
        let emailField = app.textFields["emailInput"]
        emailField.tap()
        emailField.typeText("user@test.com")

        let passwordField = app.secureTextFields["passwordInput"]
        passwordField.tap()
        passwordField.typeText("password123")

        app.buttons["loginButton"].tap()

        let homeLabel = app.staticTexts["homeTitle"]
        XCTAssertTrue(homeLabel.exists)
    }
}

Esperas e sincronização

O XCUITest suporta esperas explícitas através do XCTWaiter e predicados NSPredicate. Por exemplo, esperar que um elemento apareça em 5 segundos: XCTWaiter().wait(for: [expectation], timeout: 5). Ao contrário do Detox, o XCUITest não possui sincronização automática com requisições de rede.

// Aguardando o elemento aparecer com tempo limite
let expectedElement = app.staticTexts["welcomeMessage"]
let existsPredicate = NSPredicate(format: "exists == true")
let expectation = XCTNSNotificationExpectation(object: expectedElement)
let result = XCTWaiter().wait(
    for: [expectation], timeout: 5
)
XCTAssertEqual(result, .completed)

Recursos avançados do XCUITest

O XCUITest suporta testes de cenários complexos: gestos multitoque, notificações push, Deep Links, SFSafariViewController e interação entre aplicativos. Os intents do Siri também podem ser testados através do XCUITest com simulação do Siri Remote.

Teste de gestos

O XCUITest suporta todos os gestos populares: tap, doubleTap, pressForDuration, swipeUp/Down/Left/Right, pinch, rotate, twoFingerTap. Para cenários complexos, usa-se XCUIGesture com coordenadas e duração personalizadas. Isso permite testar gestos personalizados como desenho ou arrastar e soltar.

Intercepção de requisições de rede

A partir do Xcode 12, o XCUITest suporta intercepção de requisições de rede através do XCTestExpectation e URLProtocol. Isso permite testar o aplicativo em modo offline ou com respostas de servidor simuladas sem modificar o código do aplicativo.

XCUITest em CI/CD

O XCUITest é executado em ambientes CI através do xcodebuild com a flag test. Para execução paralela em vários simuladores, usa-se xcodebuild -testPlan com configuração de execução paralela no esquema do Xcode. GitHub Actions, Bitrise e Jenkins possuem suporte integrado para XCUITest.

Configuração para CI

Para CI, é necessário configurar code signing, provisioning profiles e especificar o destino (simulador ou dispositivo). Testes iOS no simulador não requerem certificados. Para dispositivos reais, é necessária assinatura automática através do Xcode Cloud ou Fastlane.

# Executando XCUITest no simulador via xcodebuild
xcodebuild test \
  -project MyApp.xcodeproj \
  -scheme MyApp \
  -destination 'platform=iOS Simulator,name=iPhone 15,OS=17.5' \
  -resultBundlePath ./TestResults \
  -parallel-testing-enabled YES \
  -parallel-testing-worker-count 4

Teste de acessibilidade com XCUITest

O XCUITest está intimamente ligado à API de Acessibilidade da Apple, já que a busca de elementos é baseada em atributos de acessibilidade. O teste de acessibilidade não é apenas uma forma de encontrar elementos, mas também de verificar a acessibilidade do aplicativo para pessoas com deficiência. O XCUITest pode verificar accessibilityLabel, traits e hints.

Verificação do VoiceOver

VoiceOver é o leitor de tela da Apple para usuários com deficiência visual. O XCUITest permite verificar: accessibilityLabel — se o elemento está descrito com texto claro, accessibilityTraits — se o tipo do elemento corresponde (botão, cabeçalho, imagem), e accessibilityHint — se fornece uma dica sobre o resultado da ação. Essas verificações são obrigatórias para publicação na App Store, e o XCUITest as automatiza como parte das execuções de regressão.

Verificação automática de acessibilidade

A partir do Xcode 15, o XCUITest suporta verificação integrada de acessibilidade através do XCTAttachment com o tipo accessibilityAudit. O teste relata automaticamente elementos com contraste insuficiente, imagens sem rótulo e traits incorretos. Isso substitui o Inspetor de Acessibilidade manual.

// Auditoria de acessibilidade no XCUITest
func testAccessibilityAudit() {
    let app = XCUIApplication()
    app.launch()

    let audit = XCTAttachment(accessibilityAudit: app)
    add(audit)

    // Verificando um elemento específico
    let button = app.buttons["submitButton"]
    XCTAssertTrue(button.label.count > 0)
    XCTAssertTrue(button.isAccessibilityElement)
}

Testes de desempenho no XCUITest

O XCUITest suporta medição de desempenho da UI através do XCTOSSignpostMetric e XCUIApplication.metrics. Pode-se medir o tempo de inicialização do aplicativo, a velocidade de navegação e o tempo de resposta a gestos. Os testes de desempenho são executados com medição de linha de base e falham automaticamente quando o limite é excedido. Isso ajuda a prevenir regressões de desempenho antes que cheguem aos usuários em uma versão de lançamento.

Configuração de linha de base

A linha de base (baseline) é o tempo de execução de referência de um teste. O Xcode lembra a linha de base para cada teste em um modelo de dispositivo e versão do iOS específicos. Se uma nova execução exceder a linha de base em uma porcentagem determinada (padrão 10%), o teste é considerado falho. Para atualizar a linha de base, usa-se o comando Edit Baseline no relatório de testes. É importante recalcular a linha de base ao atualizar a versão do iOS ou alterar o modelo de dispositivo para o parque de CI.

Monitoramento de estabilidade de testes

Para monitorar a estabilidade dos testes do XCUITest, são usadas flags: continueAfterFailure (se continuar o teste após a primeira falha) e planos de teste do Xcode com configurações de repetição. Recomenda-se configurar a reinicialização automática de testes com falha (retry) — até 3 tentativas para testes instáveis relacionados a temporização de animações ou atrasos de rede.

Teste de notificações push e Deep Links

O XCUITest suporta teste de notificações push e Deep Links através do springboard e launchArguments. Para notificações push, usa-se XCUIApplication().launchArguments com o parâmetro -UNUserNotificationCenter e envio através do XCTest. Deep Links são testados através de open URL com um esquema personalizado — o XCUITest intercepta o diálogo do sistema e verifica se o aplicativo abriu com a tela correta. Para testar o cenário de resposta a notificação, usa-se XCUIApplication().springboard, que simula tocar no banner de notificação no centro de notificações do iOS. Esses cenários são críticos para aplicativos com deep links e campanhas push, onde é necessário verificar o tratamento correto de chamadas externas.

Integração com Instruments

Para a criação de perfis de desempenho detalhados, o XCUITest se integra ao Instruments. Durante o teste, pode-se iniciar a criação de perfis do Time Profiler, Core Animation ou Leaks através do XCTMetric. Os resultados da criação de perfis são salvos no relatório e disponíveis para análise no Xcode. Isso é especialmente útil para otimizar o tempo de inicialização do aplicativo, a navegação entre telas e o desempenho de animações — gargalos típicos em aplicativos iOS.