BDD em Swift: como escrever testes que o negócio entende

Por que os testes comuns não salvam e o que é BDD

Todo desenvolvedor iOS já passou por esta situação: você escreveu uma centena de testes unitários, cobertura de 90%, mas na próxima demonstração o gerente diz: "Por que quando clico neste botão nada acontece?". Você olha o código — tudo funciona. O problema é que testes unitários verificam o código, não o comportamento do sistema. É aqui que o BDD (Behaviour-Driven Development) entra em cena — uma metodologia que elimina a fronteira entre testes "técnicos" e "lógica de negócio".

BDD em Swift não é apenas um termo da moda. É uma forma de escrever testes que podem ser lidos não só pelo desenvolvedor, mas também pelo analista, testador ou até mesmo pelo cliente. Neste artigo, vamos explorar como implementar behaviour-driven development no seu projeto iOS, usando os frameworks Quick e Nimble, e mostrar exemplos práticos em Swift.

O que é BDD em termos simples

Imagine que você não está escrevendo testes, mas sim um roteiro de filme. No roteiro, há personagens (usuário, sistema), eventos (clique em botão, envio de requisição) e um resultado esperado (aparecimento de alerta, atualização da interface). BDD é exatamente esse "roteiro", só que para o seu aplicativo.

A ideia principal: os testes devem descrever o comportamento do sistema do ponto de vista do usuário. Em vez de "o método saveUser() retorna true", você escreve "quando o usuário insere um email válido e clica em 'Salvar', o sistema exibe a mensagem 'Sucesso'".

Como o BDD difere do TDD

Muitos confundem BDD com TDD (Test-Driven Development). A diferença é simples:

• TDD — escrevemos o teste, depois o código, depois refatoramos. Foco na correção da implementação.
• BDD — escrevemos o cenário de comportamento, depois o código que implementa esse comportamento. Foco no valor para o usuário.

BDD é uma evolução do TDD. Se o TDD responde à pergunta "o código funciona corretamente?", o BDD responde "o código faz o que o negócio precisa?"

Ferramentas para BDD em Swift

No mundo Swift, existem duas principais "baleias" para behaviour-driven development:

• Quick — framework para escrever testes no estilo BDD. Ele substitui o XCTest padrão e fornece a sintaxe describe/context/it.
• Nimble — biblioteca de "matchers" (verificações). Em vez de XCTAssertEqual, você escreve expect(value).to(equal(5)) — que se lê como uma frase em inglês.

Essas ferramentas funcionam muito bem juntas e permitem escrever testes que parecem uma especificação.

Instalação do Quick e Nimble via Swift Package Manager

Adicione as dependências no seu Package.swift ou via Xcode: File → Add Packages → insira a URL do repositório do Quick: https://github.com/Quick/Quick.git e do Nimble: https://github.com/Quick/Nimble.git.

Exemplo para Package.swift:

// swift-tools-version:5.9import PackageDescription

let package = Package(    name: "MyApp",    dependencies: [        .package(url: "https://github.com/Quick/Quick.git", from: "7.0.0"),        .package(url: "https://github.com/Quick/Nimble.git", from: "13.0.0"),    ],    targets: [        .target(name: "MyApp"),        .testTarget(            name: "MyAppTests",            dependencies: ["MyApp", "Quick", "Nimble"]        )    ])

Escrevendo o primeiro teste BDD em Swift

Suponha que temos um simples LoginService que verifica login e senha. Em vez de escrever um XCTest tedioso, vamos criar um teste no estilo BDD.

Código do serviço (para contexto)

class LoginService {    func authenticate(username: String, password: String) -> Result<User, LoginError> {        guard !username.isEmpty else { return .failure(.emptyUsername) }        guard !password.isEmpty else { return .failure(.emptyPassword) }        guard pas