Quick/Nimble pour Swift : guide complet avec exemples

Qu'est-ce que Quick/Nimble et pourquoi les utiliser ?

Quick et Nimble sont deux bibliothèques complémentaires pour le langage Swift, conçues pour écrire des tests dans le style Behavior-Driven Development (BDD). Le BDD est une méthodologie de développement qui se concentre sur le comportement de l'application du point de vue de l'utilisateur, plutôt que sur les détails techniques d'implémentation. Au lieu d'assertions sèches comme XCTAssertEqual(a, b), vous décrivez ce qui devrait se produire : "lorsque l'utilisateur appuie sur le bouton, l'application doit afficher un message de bienvenue".

Quick est un framework pour décrire des scénarios de test. Il fournit un DSL (Domain-Specific Language) qui permet de structurer les tests sous forme de hiérarchie : describe (description du contexte), context (précision des conditions) et it (test spécifique). Cela rend les tests lisibles et compréhensibles même pour les membres non techniques de l'équipe (chefs de projet, analystes).

Nimble est une bibliothèque pour écrire des matchers (assertions). Au lieu des XCTAssert standard, vous utilisez des constructions expressives : expect(value).to(equal(expected)), expect(array).to(contain(element)). Nimble fournit des dizaines de matchers intégrés et permet d'en créer facilement de nouveaux.

Pourquoi en avez-vous besoin ?

• Lisibilité : Les tests en BDD ressemblent à une spécification. Vous pouvez les montrer à votre client et vous assurer que les exigences sont bien comprises.
• Structuration : La hiérarchie describe/context/it aide à organiser les tests de manière logique, évitant le "code spaghetti".
• Matchers expressifs : Nimble rend les assertions plus visuelles et informatives. Les erreurs dans les tests deviennent immédiatement compréhensibles.
• Facilité de débogage : Lorsqu'un test échoue, vous ne voyez pas simplement "attendu 5, obtenu 3", mais le contexte complet : "Lorsque l'utilisateur saisit un mot de passe incorrect, le système doit afficher une erreur".

Installation de Quick/Nimble

Quick et Nimble s'installent via CocoaPods ou Swift Package Manager (SPM). Nous allons voir les deux méthodes.

Installation via CocoaPods

Si vous n'utilisez pas encore CocoaPods, installez-le :

sudo gem install cocoapods

À la racine de votre projet, créez un fichier Podfile et ajoutez-y :

target 'YourAppName' do
  # Dépendances normales (si nécessaire)
  use_frameworks!

  target 'YourAppNameTests' do
    inherit! :search_paths
    pod 'Quick'
    pod 'Nimble'
  end
end

Exécutez ensuite :

pod install

Ouvrez ensuite le fichier .xcworkspace.

Installation via Swift Package Manager (SPM)

Dans Xcode : File → Add Packages... et saisissez l'URL du dépôt :

https://github.com/Quick/Quick.git
https://github.com/Quick/Nimble.git

Sélectionnez la dernière version stable et ajoutez les paquets à votre cible de test (YourAppNameTests).

Démarrage rapide : premier test

Créons une classe simple Calculator et testons-la.

Classe à tester

// Calculator.swift
import Foundation

class Calculator {
    func add(_ a: Int, _ b: Int) -> Int {
        return a + b
    }

    func subtract(_ a: Int, _ b: Int) -> Int {
        return a - b
    }

    func multiply(_ a: Int, _ b: Int) -> Int {
        return a * b
    }
}

Test avec Quick et Nimble

// CalculatorSpec.swift
import Quick
import Nimble
@testable import YourAppName // Remplacez par le nom de votre application

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

            beforeEach {
                calculator = Calculator(