SwiftHTML & CSSSolidityDesenvolvimento de JogosSolana/Rust
18.11.2024

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

  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

Did you like this article? Rate it from 1 to 5:

Thank you for voting!