Tests en Swift : unitaires, d'intégration, E2E — guide complet

Introduction : Pourquoi tester les applications Swift ?

Le développement d'une application iOS ou macOS de qualité est impossible sans des tests rigoureux. Dans l'écosystème Swift, il existe un framework puissant appelé XCTest qui permet d'écrire les trois niveaux de tests : unitaires (unit), d'intégration (integration) et de bout en bout (E2E). Chacun de ces niveaux a sa propre zone de responsabilité et aide à détecter les bugs à différentes étapes du développement.

Dans cet article, nous allons voir comment configurer et écrire correctement des tests pour les applications Swift, en utilisant des pratiques et des outils modernes. Vous apprendrez en quoi les différents types de tests diffèrent et obtiendrez des exemples de code prêts à l'emploi que vous pourrez appliquer immédiatement dans votre projet.

Tests unitaires en Swift

Les tests unitaires sont le fondement de la pyramide des tests. Ils vérifient le fonctionnement de composants individuels (méthodes, classes, structures) en isolation des dépendances externes.

Configuration des tests unitaires dans Xcode

Pour créer une cible de test dans Xcode, lors de la création du projet, il suffit de cocher la case "Include Tests". Si le projet existe déjà, ajoutez une nouvelle cible : File → New → Target → iOS Unit Testing Bundle.

Exemple de base d'un test unitaire

Prenons un exemple simple de test d'une calculatrice :

import XCTest

final class CalculatorTests: XCTestCase {        var calculator: Calculator!        override func setUpWithError() throws {        calculator = Calculator()    }        override func tearDownWithError() throws {        calculator = nil    }        func testAddition() {        // Given        let a = 5        let b = 3                // When        let result = calculator.add(a, b)                // Then        XCTAssertEqual(result, 8, "5 + 3 doit être égal à 8")    }        func testDivisionByZero() {        XCTAssertThrowsError(try calculator.divide(10, 0)) { error in            XCTAssertEqual(error as? CalculatorError, CalculatorError.divisionByZero)        }    }}

Bonnes pratiques pour les tests unitaires

• Isolation : Chaque test doit être indépendant. Utilisez setUpWithError et tearDownWithError pour la préparation et le nettoyage.
• Modèle AAA : Arrange (préparation), Act (action), Assert (vérification).
• Une vérification par test : Un test idéal ne vérifie qu'un seul comportement.
• Nommage : Utilisez des noms descriptifs : testMethodName_WhenCondition_ExpectedResult.

Tests d'intégration en Swift

Les tests d'intégration vérifient l'interaction entre les composants : travail avec la base de données, requêtes réseau, système de fichiers. Contrairement aux tests unitaires, on ne mocke pas tout ici, on teste les interactions réelles.

Test de Core Data

Exemple de test de travail avec Core Data :

import XCTest@testable import MyApp

final class CoreDataIntegrationTests: XCTestCase {        var coreDataStack: CoreDataStack!        override func setUpWithError() throws {        coreDataStack = CoreDataStack(inMemory: true) // Utilisation d'un stockage en mémoire    }        func testSaveAndFetchUser() {        // Arrange        let user = User(context: coreDataStack.viewContext)        user.name = "Ivan"        user.age = 30                // Act        try? coreDataStack.viewContext.save()                let fetchRequest: NSFetchRequest<User> = User.fetchRequest()        let users = try? coreDataStack.viewContext.fetch(fetchRequest)                // Assert        XCTAssertEqual(users?.count, 1)        XCTAssertEqual(users?.first?.name, "Ivan")    }}

Test de la couche réseau

Pour les tests d'intégration réseau, utilisez un