Por que o ambiente compartilhado de homologação trava times mobile
Quem trabalha com aplicativos corporativos conhece bem a cena: você termina uma tela complexa às 14h, abre o simulador para rodar os testes de integração e o pipeline falha com erro 502. Você pergunta no canal do backend e descobre que outra squad reiniciou o serviço de autenticação, limpou a massa de dados de testes ou subiu um contrato pela metade. Meia tarde vai embora sem uma única linha de código mobile com defeito.
O estrago fica ainda pior nos testes automatizados de interface (XCUITest ou Espresso) que dependem de servidores de homologação via internet. Uma oscilação de 400 milissegundos na latência do ambiente compartilhado, um token de teste que expirou ontem à noite ou um limite diário atingido na conta de QA bastam para derrubar o build no CI. Quando a taxa de falsos negativos (flakiness) passa de 10%, acontece o pior efeito colateral possível: os desenvolvedores param de investigar o build vermelho e criam o hábito de clicar em "re-run" até ficar verde. Nesse momento, a suíte deixou de proteger o código.
Definição prática de teste hermético: uma execução confiável não depende de internet, DNS externo, banco compartilhado nem relógio real do sistema. Toda resposta de rede e todo estado local nascem dentro da própria execução e terminam descartados ao final do caso de teste.
Escolhendo a técnica certa de interceptação de rede
Não existe uma única ferramenta ideal para todas as camadas da pirâmide de testes. Em testes unitários e de integração rodando dentro do mesmo processo do aplicativo (XCTest), interceptar chamadas em memória é mais rápido e simples. Já nos testes de interface (XCUITest), o runner roda em um processo separado do aplicativo, então o código de teste não consegue injetar objetos diretamente na memória da aplicação. Nesse cenário, um servidor HTTP local (como WireMock ou Swifter) escutando em 127.0.0.1 resolve o isolamento com elegância.
| Abordagem | Camada ideal | Velocidade média | Principal ponto de atenção |
|---|---|---|---|
URLProtocol em memória | Testes unitários e de integração de módulos | Milissegundos por caso | Exige isolamento por sessão para não gerar race conditions em execução paralela. |
| Mock Server local (WireMock / Swifter) | Testes de UI (XCUITest) e desenvolvimento offline | 1 a 4 segundos por fluxo | Precisa gerenciar porta livre no runner e injetar base URL via argumentos de launch. |
| Gravação e replay via Proxy | Exploração manual e reprodução de bugs de produção | Média | Payloads gravados podem conter dados sensíveis e envelhecem rápido se não higienizados. |
| Homologação real (Staging) | Smoke tests curtos (3 a 5 fluxos) antes do release | Lenta e sujeita a rede | Nunca usar como bloqueador de Pull Request; manter apenas em pipeline agendado ou pré-release. |
Simulando fluxos com estado no WireMock
Um engano comum é achar que mock servers servem apenas para devolver um JSON estático de sucesso. O verdadeiro valor aparece quando você reproduz cenários que seriam lentos ou quase impossíveis de montar em homologação: sessão que expira no meio de uma transferência, resposta 429 (rate limit), timeout parcial ou lista vazia.
No WireMock, o recurso de scenarioName permite criar uma máquina de estados simples para o mesmo endpoint. No mapeamento abaixo, a primeira chamada para listar cartões devolve 401 Unauthorized; o aplicativo dispara a renovação de token e, na segunda chamada, o mock devolve 200 OK com o payload esperado:
{
"mappings": [
{
"scenarioName": "TokenRefreshFlow",
"requiredScenarioState": "Started",
"newScenarioState": "TokenRefreshed",
"request": {
"method": "GET",
"urlPath": "/v1/accounts/cards"
},
"response": {
"status": 401,
"headers": { "Content-Type": "application/json" },
"jsonBody": { "error": "token_expired" }
}
},
{
"scenarioName": "TokenRefreshFlow",
"requiredScenarioState": "TokenRefreshed",
"request": {
"method": "GET",
"urlPath": "/v1/accounts/cards",
"headers": {
"Authorization": { "matches": "Bearer refreshed_.*" }
}
},
"response": {
"status": 200,
"headers": { "Content-Type": "application/json" },
"bodyFileName": "responses/cards_success_payload.json",
"fixedDelayMilliseconds": 15
}
}
]
} Para conectar o aplicativo a esse servidor durante o XCUITest sem contaminar o binário de produção, passe o endereço local pelos argumentos de inicialização do processo (app.launchArguments += ["-mockBaseURL", "http://127.0.0.1:8089"]) e leia essa configuração apenas dentro de diretivas de compilação para ambientes de teste ou homologação. Assim, o código de produção segue imutável e a camada de rede nem sabe que está falando com o loopback local.
URLProtocol seguro para testes paralelos em Swift
Muitos tutoriais de iOS ensinam a criar um MockURLProtocol usando um dicionário estático global (static var stubbedData). Esse modelo funciona enquanto você roda dez testes em série, mas quebra de forma aleatória assim que habilita testes paralelos no Xcode: o teste A sobrescreve o stub enquanto o teste B está no meio de uma requisição, gerando falhas difíceis de reproduzir localmente.
A correção é simples e limpa: proteja o registro de handlers com um lock sincronizado e associe cada handler a um identificador único enviado em um cabeçalho da URLSessionConfiguration.ephemeral criada exclusivamente para aquele teste. O resultado abaixo roda com segurança total mesmo com múltiplos workers simultâneos:
import Foundation
import os
public final class IsolatedMockURLProtocol: URLProtocol {
public typealias RequestHandler = @Sendable (URLRequest) throws -> (HTTPURLResponse, Data)
private static let testIdHeader = "X-Test-Session-ID"
private static let lock = OSAllocatedUnfairLock()
private static var handlers: [String: RequestHandler] = [:]
public static func makeSession(
testID: String = UUID().uuidString,
handler: @escaping RequestHandler
) -> (session: URLSession, cleanup: () -> Void) {
lock.withLock { handlers[testID] = handler }
let config = URLSessionConfiguration.ephemeral
config.protocolClasses = [IsolatedMockURLProtocol.self]
config.httpAdditionalHeaders = [testIdHeader: testID]
let session = URLSession(configuration: config)
let cleanup = {
session.invalidateAndCancel()
lock.withLock { _ = handlers.removeValue(forKey: testID) }
}
return (session, cleanup)
}
public override class func canInit(with request: URLRequest) -> Bool { true }
public override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
public override func startLoading() {
let testID = request.value(forHTTPHeaderField: Self.testIdHeader)
let handler = Self.lock.withLock { testID.flatMap { Self.handlers[$0] } }
guard let handler else {
client?.urlProtocol(self, didFailWithError: URLError(.badServerResponse))
return
}
do {
let (response, data) = try handler(request)
client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
client?.urlProtocol(self, didLoad: data)
client?.urlProtocolDidFinishLoading(self)
} catch {
client?.urlProtocol(self, didFailWithError: error)
}
}
public override func stopLoading() {}
} Essa mesma filosofia de isolamento via injeção de dependência vale para hardware e serviços nativos do sistema operacional, como sensores e GPS. Se quiser aplicar o padrão também fora da camada HTTP, vale consultar o artigo sobre abstração de CoreLocation com injeção de dependência em Swift.
A maior armadilha dos mocks: o drift de contrato
Seria desonesto vender testes herméticos sem falar do seu ponto fraco mais perigoso. Se o backend renomear um campo de due_date para dueDate ou mudar um número inteiro para string, sua suíte 100% mockada continuará passando toda verde enquanto o aplicativo quebra em homologação ou produção. Esse descolamento entre os arquivos JSON locais e a API real chama-se contract drift.
Existem três formas práticas de fechar essa brecha sem abrir mão da velocidade dos mocks. A primeira é validar automaticamente seus arquivos de fixture JSON contra o arquivo OpenAPI/Swagger oficial do backend no pipeline de CI: se o contrato mudar no repositório da API, o validador acusa imediatamente qual stub do aplicativo ficou desatualizado. A segunda é manter uma bateria enxuta de testes de contrato (como Pact) para os endpoints mais críticos de negócio. A terceira é rodar uma suíte curta de smoke tests (três a cinco caminhos vitais, como login e consulta principal) contra staging uma vez por noite e antes do fechamento da release, nunca bloqueando cada Pull Request do dia.
Também não esqueça de limpar o estado persistido no simulador entre um teste de UI e outro. Um teste que herda chaves de UserDefaults, cookies ou tokens no Keychain deixados pelo teste anterior deixa de ser hermético mesmo sem acessar a internet. Adicione uma flag de inicialização (por exemplo, -resetLocalState) que zera o storage efêmero antes de montar a primeira tela.
Ganhos reais no ciclo de entrega e checklist de adoção
Em um projeto real com cerca de 60 testes de interface críticos, sair de staging compartilhado para WireMock local derrubou o tempo de execução de 42 minutos para menos de 6 minutos e reduziu as falhas intermitentes de quase 25% para menos de 1%. Esse ganho conversa diretamente com as práticas de paralelização e cache que detalhei em otimização de pipelines de CI/CD em iOS.
Para migrar uma suíte atual sem parar as entregas da equipe, siga uma ordem pragmática:
- Mapeie durante duas semanas quais testes mais falham por timeout, erro 5xx ou massa de dados corrompida em staging.
- Crie a injeção da URL base por argumento de launch e o reset de
UserDefaultse Keychain em builds de teste. - Migre primeiro os fluxos mais instáveis para stubs locais versionados no mesmo repositório do aplicativo.
- Adicione cobertura explícita para cenários de erro que antes ninguém testava: timeout, HTTP 401 com refresh, HTTP 429, HTTP 500 e JSON incompleto.
- Configure a validação dos stubs contra o esquema OpenAPI no CI para impedir drift silencioso de contrato.
- Reduza os testes acoplados a staging a um conjunto pequeno de smoke tests pré-release, deixando os Pull Requests 100% livres de dependências externas.
