0Pricing
Swift Academy · Leçon

Tester le code asynchrone (XCTest)

Écrivez des tests asynchrones avec XCTest : marquez les tests async , utilisez await et throws , testez les échecs et les délais d’attente, puis vérifiez les résultats de la concurrence structurée.

Tester le code asynchrone (XCTest) est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 3 leçons au total.

Tests asynchrones : notions de base

XCTest prend en charge les tests async. Gardez vos tests courts et déterministes :

  • Déclarez des tests async et utilisez await
  • Utilisez throws et do/catch pour gérer les échecs
  • Remplacez les appels à sleep par de petits objets simulés

Cas de réussite asynchrone

Marquez le test comme async et appelez le SUT avec await. Écrivez des assertions normales comme XCTAssertEqual.

import XCTest
import Foundation

// System Under Test (SUT)
func fetchValue() async -> Int {
    try? await Task.sleep(nanoseconds: 50_000_000)
    return 42
}

final class AsyncBasicsTests: XCTestCase {
    func testFetchValue_returns42() async {
        let v = await fetchValue()
        XCTAssertEqual(v, 42)
    }
}

Levée d’erreur asynchrone et assertions

Utilisez des tests async throws. Pour des erreurs précises, interceptez-les et faites une correspondance de motif afin de garder l’intention claire.

import XCTest

enum NetError: Error { case offline }

func loadNumber(online: Bool) async throws -> Int {
    try await Task.sleep(nanoseconds: 30_000_000)
    if !online { throw NetError.offline }
    return 7
}

final class AsyncThrowingTests: XCTestCase {
    func testLoadNumber_success() async throws {
        let n = try await loadNumber(online: true)
        XCTAssertEqual(n, 7)
    }

    func testLoadNumber_offline_throws() async {
        do {
            _ = try await loadNumber(online: false)
            XCTFail("Expected error")
        } catch NetError.offline {
            // expected
        } catch {
            XCTFail("Unexpected error: \\(error)")
        }
    }
}

Résultats parallèles

La concurrence structurée est facile à tester : utilisez async let et vérifiez le résultat final. Gardez les délais très courts pour éviter les tests instables.

import XCTest

func compute(_ x: Int) async -> Int {
    try? await Task.sleep(nanoseconds: 10_000_000)
    return x * x
}

final class ParallelTests: XCTestCase {
    func testParallel_asyncLet_sumsSquares() async {
        async let a = compute(2)
        async let b = compute(3)
        let sum = await (a + b)
        XCTAssertEqual(sum, 13) // 4 + 9
    }
}

Test des délais d’expiration

Testez les délais d’expiration en mettant l’opération en concurrence avec une courte pause. Utilisez des durées très courtes pour que les tests restent rapides et stables.

import XCTest

enum TimeoutError: Error { case timedOut }

func withTimeout<T>(
    seconds: Double,
    operation: @escaping () async throws -> T
) async throws -> T {
    try await withThrowingTaskGroup(of: T.self) { group in
        group.addTask { try await operation() }
        group.addTask {
            try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
            throw TimeoutError.timedOut
        }
        let first = try await group.next()!
        group.cancelAll()
        return first
    }
}

final class TimeoutTests: XCTestCase {
    func testTimeout_timesOutFast() async {
        do {
            _ = try await withTimeout(seconds: 0.01) {
                try await Task.sleep(nanoseconds: 50_000_000) // slower than timeout
                return "OK"
            }
            XCTFail("Expected timeout")
        } catch TimeoutError.timedOut {
            // expected
        } catch {
            XCTFail("Unexpected error: \\(error)")
        }
    }
}

Attentes (héritées)

Pour les anciens rappels, utilisez toujours expectation/wait. Préférez les tests asynchrones pour le nouveau code.

import XCTest

// Legacy API with a completion handler
func legacyFetch(_ completion: @escaping (String) -> Void) {
    Task { try? await Task.sleep(nanoseconds: 20_000_000); completion("done") }
}

final class ExpectationTests: XCTestCase {
    func testLegacy_withExpectation() {
        let exp = expectation(description: "legacy finishes")
        legacyFetch { value in
            XCTAssertEqual(value, "done")
            exp.fulfill()
        }
        wait(for: [exp], timeout: 1.0)
    }
}

Style moderne des tests asynchrones

Vérification rapide : quelle est la meilleure pratique pour tester une fonction asynchrone ?

Récapitulatif

Récapitulatif : utilisez les méthodes XCTest async avec await, vérifiez les chemins de réussite et d’échec, gardez les délais très courts et réservez les attentes aux anciens rappels.

Questions Fréquemment Posées

La leçon « Tester le code asynchrone (XCTest) » est-elle gratuite ?

Oui — le texte complet de « Tester le code asynchrone (XCTest) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Tester le code asynchrone (XCTest) » ?

Écrivez des tests asynchrones avec XCTest : marquez les tests async , utilisez await et throws , testez les échecs et les délais d’attente, puis vérifiez les résultats de la concurrence structurée. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 3.

Combien de temps prend la leçon « Tester le code asynchrone (XCTest) » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Producteur/consommateur, pipelines et délais d’attente
  2. Adapter les rappels hérités et Combine à async/await
  3. Tester le code asynchrone (XCTest)
← Retour à Swift Academy