Pruebas en Swift: frameworks y herramientas

Pruebas en Swift (iOS/macOS): frameworks y herramientas

El desarrollo de aplicaciones de calidad para las plataformas de Apple es impensable sin pruebas confiables. El ecosistema de Swift ofrece tanto soluciones integradas como potentes frameworks de terceros que cubren todos los niveles: desde pruebas unitarias hasta pruebas de UI. En este artículo, analizaremos en detalle las principales herramientas de pruebas para iOS/macOS, sus puntos fuertes y proporcionaremos ejemplos prácticos en Swift.

1. XCTest — el framework estándar de Apple

XCTest es la base de todas las pruebas en Xcode. Está integrado en el IDE, admite ejecución paralela, medición de rendimiento y pruebas de UI. Para crear una prueba, basta con heredar una clase de XCTestCase.

Ejemplo de prueba unitaria con 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, "Se esperaba 5, se obtuvo \\(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))            }        }    }}

Características clave de XCTest:

XCTAssertEqual, XCTAssertTrue, XCTAssertNil — verificaciones básicas.
XCTAssertThrowsError — pruebas de excepciones.
measure — medición de rendimiento.
Soporte para pruebas asíncronas mediante XCTestExpectation.

2. Quick y Nimble — estilo BDD de pruebas

Quick es un framework para escribir pruebas en estilo Behaviour-Driven Development (BDD). Permite describir el comportamiento de la aplicación en lenguaje natural. Nimble es una biblioteca de matchers que hace que las aserciones sean más legibles.

Ejemplo con 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))                }            }        }    }}

Ventajas:

Jerarquías legibles: describe → context → it.
Nimble proporciona un rico conjunto de matchers: equal, beNil, beCloseTo, contain y otros.
Excelente integración con Xcode y los informes.