Lição: 62: Desenvolvimento Orientado a Testes em Swift
O Desenvolvimento Orientado a Testes (TDD) é um processo de desenvolvimento de software que se baseia na repetição de um ciclo simples: escrever um teste, implementar o código para passar o teste e, em seguida, refatorar o código. Esta aula irá apresentar a você o TDD em Swift, cobrindo seus princípios, benefícios e um exemplo prático.
Princípios do TDD
-
Escreva um Teste: Comece escrevendo um teste para uma funcionalidade específica que você deseja implementar. O teste deve falhar inicialmente, pois você ainda não escreveu o código que ele deve validar.
-
Execute o Teste: Rode o teste para garantir que ele falhe. Isso confirma que seu teste é válido e que a funcionalidade que ele testa ainda não está implementada.
-
Escreva o Código Mínimo: Escreva apenas o código necessário para fazer o teste passar. Foque em fazer a funcionalidade funcionar, e não em torná-la perfeita.
-
Execute Todos os Testes: Assim que seu teste passar, execute todos os testes para garantir que seu novo código não quebrou nenhuma funcionalidade existente.
-
Refatore: Limpe o código garantindo que todos os testes ainda passem. Isso inclui melhorar a legibilidade, remover duplicações e otimizar a performance.
-
Repita: Continue esse ciclo para cada nova funcionalidade.
Benefícios do TDD
- Qualidade de Código Aprimorada: Escrever testes primeiro geralmente leva a um código melhor projetado.
- Menos Bugs: Com os testes em funcionamento, você pode garantir que novas alterações não introduzam regressões.
- Documentação: Os testes servem como documentação para seu código, fornecendo exemplos de como usá-lo.
- Confiança: Saber que todos os testes passam dá aos desenvolvedores confiança para fazer alterações.
Exemplo: Calculadora Básica
Vamos tomar um exemplo simples de construção de uma calculadora básica usando TDD em Swift. Implementaremos adição, subtração, multiplicação e divisão.
Passo 1: Criar um Novo Pacote Swift
Primeiro, crie um novo pacote Swift para seu projeto.
swift package init --type executable
Passo 2: Escrever o Primeiro Teste
Navegue até o diretório Tests
do seu pacote e crie um novo arquivo de teste chamado CalculatorTests.swift
.
import XCTest
@testable import NomeDoSeuPacote
final class CalculatorTests: XCTestCase {
func testAdicao() {
let calculadora = Calculadora()
let resultado = calculadora.adicionar(2, 3)
XCTAssertEqual(resultado, 5)
}
}
Passo 3: Execute o Teste e Veja a Falha
Execute seus testes usando o seguinte comando:
swift test
Você verá um erro porque a classe Calculadora
e o método adicionar
ainda não existem.
Passo 4: Escreva o Código Mínimo
Agora, crie a classe Calculadora
no diretório Sources
.
public struct Calculadora {
public init() {}
public func adicionar(_ a: Int, _ b: Int) -> Int {
return a + b
}
}
Passo 5: Execute Todos os Testes
Execute seus testes novamente:
swift test
Agora, o teste de adição deve passar.
Passo 6: Adicione Mais Testes
Continue adicionando testes para subtração, multiplicação e divisão.
func testSubtracao() {
let calculadora = Calculadora()
let resultado = calculadora.subtrair(5, 3)
XCTAssertEqual(resultado, 2)
}
func testMultiplicacao() {
let calculadora = Calculadora()
let resultado = calculadora.multiplicar(4, 3)
XCTAssertEqual(resultado, 12)
}
func testDivisao() {
let calculadora = Calculadora()
let resultado = calculadora.dividir(6, 2)
XCTAssertEqual(resultado, 3)
}
func testDivisaoPorZero() {
let calculadora = Calculadora()
XCTAssertThrowsError(try calculadora.dividir(1, 0))
}
Passo 7: Implemente o Código
Agora, atualize a classe Calculadora
para suportar essas operações:
public struct Calculadora {
public init() {}
public func adicionar(_ a: Int, _ b: Int) -> Int {
return a + b
}
public func subtrair(_ a: Int, _ b: Int) -> Int {
return a - b
}
public func multiplicar(_ a: Int, _ b: Int) -> Int {
return a * b
}
public func dividir(_ a: Int, _ b: Int) throws -> Int {
guard b != 0 else {
throw ErroDivisao.divididoPorZero
}
return a / b
}
enum ErroDivisao: Error {
case divididoPorZero
}
}
Passo 8: Refatore e Limpe
Após implementar as funções, revise seu código em busca de melhorias. Certifique-se de que seus testes ainda passem após qualquer refatoração.
Conclusão
O Desenvolvimento Orientado a Testes é uma abordagem poderosa que leva a um código de alta qualidade e fácil manutenção. Ao seguir os princípios do TDD, os desenvolvedores podem construir aplicações robustas com confiança. À medida que você se familiariza mais com o TDD, provavelmente descobrirá que ele se torna uma parte integral do seu fluxo de trabalho de desenvolvimento em Swift. Boa codificação!