18.11.2024

Aula 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

1. 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.

2. 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.

3. 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.

4. 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.

5. Refatore: Limpe o código garantindo que todos os testes ainda passem. Isso inclui melhorar a legibilidade, remover duplicações e otimizar a performance.

6. 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!

Video

Navigation