Testes em Swift (iOS/macOS): frameworks e ferramentas

Testes em Swift (iOS/macOS): frameworks e ferramentas

O desenvolvimento de aplicações de qualidade para as plataformas Apple é impensável sem testes confiáveis. O ecossistema Swift oferece tanto soluções integradas quanto poderosos frameworks de terceiros que cobrem todos os níveis: desde testes unitários até testes de UI. Neste artigo, analisaremos detalhadamente as principais ferramentas de teste para iOS/macOS, seus pontos fortes e forneceremos exemplos práticos em Swift.

1. XCTest — framework padrão da Apple

XCTest é a base para todos os testes no Xcode. Ele está integrado à IDE, suporta execução paralela, medição de desempenho e testes de UI. Para criar um teste, basta herdar a classe de XCTestCase.

Exemplo de teste unitário com XCTest

import XCTest@testable import MyApp

class CalculatorTests: XCTestCase {

    var calculator: Calculator!

    override func setUp() {        super.setUp()        calculator = Calculator()    }

    override func tearDown() {        calculator = nil        super.tearDown()    }

    func testAddition() {        let result = calculator.add(2, 3)        XCTAssertEqual(result, 5, "Esperado 5, obtido \\(result)")    }

    func testDivisionByZero() {        XCTAssertThrowsError(try calculator.divide(10, 0)) { error in            XCTAssertEqual(error as? CalculatorError, CalculatorError.divisionByZero)        }    }

    func testPerformanceExample() {        measure {            for _ in 0..<1000 {                _ = calculator.add(Int.random(in: 0...100), Int.random(in: 0...100))            }        }    }}

Principais recursos do XCTest:

• XCTAssertEqual, XCTAssertTrue, XCTAssertNil — verificações básicas.
• XCTAssertThrowsError — teste de exceções.
• measure — medição de desempenho.
• Suporte para testes assíncronos via XCTestExpectation.

2. Quick e Nimble — estilo BDD de teste

Quick é um framework para escrever testes no estilo Behaviour-Driven Development (BDD). Ele permite descrever o comportamento da aplicação em linguagem natural. Nimble é uma biblioteca de matchers que torna as asserções mais legíveis.

Exemplo com Quick + Nimble

import Quickimport Nimble@testable import MyApp

class CalculatorSpec: QuickSpec {    override func spec() {        describe("Calculator") {            var calculator: Calculator!

            beforeEach {                calculator = Calculator()            }

            context("when adding two numbers") {                it("should return the correct sum") {                    expect(calculator.add(2, 3)).to(equal(5))                }            }

            context("when dividing by zero") {                it("should throw an error") {                    expect { try calculator.divide(10, 0) }.to(throwError())                }            }

            context("performance") {                it("should be fast") {                    expect {                        for _ in 0..<1000 {                            _ = calculator.add(Int.random(in: 0...100), Int.random(in: 0...100))                        }                    }.to(beLessThan(0.1))                }            }        }    }}

Vantagens:

• Hierarquias legíveis: describe → context → it.
• Nimble fornece um rico conjunto de matchers: equal, beNil, beCloseTo, contain e outros.
• Excelente integração com Xcode e relatórios.

3. SwiftCheck — teste baseado em propriedades