Tests en Swift (iOS/macOS) : frameworks et outils

Tests en Swift (iOS/macOS) : frameworks et outils

Le développement d'applications de qualité pour les plateformes Apple est impensable sans des tests fiables. L'écosystème Swift propose à la fois des solutions intégrées et des frameworks tiers puissants qui couvrent tous les niveaux : des tests unitaires aux tests d'interface utilisateur. Dans cet article, nous analyserons en détail les principaux outils de test pour iOS/macOS, leurs points forts et fournirons des exemples pratiques en Swift.

1. XCTest — le framework standard d'Apple

XCTest est la base de tous les tests dans Xcode. Il est intégré à l'IDE, prend en charge l'exécution parallèle, la mesure des performances et les tests d'interface utilisateur. Pour créer un test, il suffit d'hériter de la classe XCTestCase.

Exemple de test unitaire avec 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, "Attendu 5, obtenu \\(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))            }        }    }}

Fonctionnalités clés de XCTest :

• XCTAssertEqual, XCTAssertTrue, XCTAssertNil — vérifications de base.
• XCTAssertThrowsError — test des exceptions.
• measure — mesure des performances.
• Prise en charge des tests asynchrones via XCTestExpectation.

2. Quick et Nimble — style de test BDD

Quick est un framework pour écrire des tests dans le style Behaviour-Driven Development (BDD). Il permet de décrire le comportement de l'application en langage naturel. Nimble est une bibliothèque de matchers qui rend les assertions plus lisibles.

Exemple avec 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))                }            }        }    }}

Avantages :

• Hiérarchies lisibles : describe → context → it.
• Nimble fournit un ensemble riche de matchers : equal, beNil, beCloseTo, contain, etc.
• Excellente intégration avec Xcode et les rapports.

3. SwiftCheck — tests basés sur les propriétés