0Pricing
Swift Academy · Leçon

Simulation fondée sur des protocoles et injection de dépendances

Injecter des doublures de test via des protocoles, sans frameworks de simulation tiers.

Simulation fondée sur des protocoles et injection de dépendances est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. 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 4 leçons au total.

Pourquoi utiliser des doublures fondées sur des protocoles ?

L'utilisation de protocoles comme points d'injection permet de remplacer les implémentations réelles par des doublures de test sans modifier le code de production.

protocol NetworkService {
  func fetch(url: URL) async throws -> Data
}
class RealNetworkService: NetworkService { /* URLSession */ }
class MockNetworkService: NetworkService { /* returns fixtures */ }

Définition du protocole

Extrayez un protocole de votre dépendance, en ne conservant que les méthodes dont votre classe a besoin.

protocol UserRepository {
  func getUser(id: Int) async throws -> User
  func saveUser(_ user: User) async throws
}

Injection via l'initialiseur

Transmettez la dépendance via l'initialiseur afin que les tests puissent fournir un mock.

class ProfileViewModel {
  private let repo: UserRepository
  init(repo: UserRepository = RealUserRepository()) {
    self.repo = repo
  }
}

Écriture d'un mock

Implémentez le protocole avec un état contrôlable : enregistrez les appels et renvoyez des valeurs de substitution.

class MockUserRepo: UserRepository {
  var fetchedIds: [Int] = []
  var stubbedUser: User = User(id: 1, name: "Test")
  func getUser(id: Int) async throws -> User {
    fetchedIds.append(id)
    return stubbedUser
  }
  func saveUser(_ user: User) async throws {}
}

Valeurs de retour simulées

Configurez les valeurs de substitution avant le test pour contrôler ce que renvoie le mock et simuler différents scénarios.

let mock = MockUserRepo()
mock.stubbedUser = User(id: 42, name: "Alice")
let vm = ProfileViewModel(repo: mock)
await vm.loadProfile(id: 42)
XCTAssertEqual(vm.userName, "Alice")

Vérification des interactions

Après avoir exécuté le système testé, vérifiez que le mock a été appelé avec les arguments attendus.

XCTAssertEqual(mock.fetchedIds, [42], "Should fetch user 42 exactly once")

Simulation des erreurs

Faites lever des erreurs par le mock afin de tester les chemins de gestion des erreurs dans le code de production.

class FailingRepo: UserRepository {
  func getUser(id: Int) async throws -> User { throw NetworkError.notFound }
  func saveUser(_ user: User) async throws { throw NetworkError.serverError(500) }
}

Injection par propriété

Vous pouvez aussi exposer la dépendance comme une propriété modifiable pour la remplacer plus simplement dans les tests.

class OrderService {
  var paymentGateway: PaymentGateway = StripeGateway()
}
let service = OrderService()
service.paymentGateway = MockPaymentGateway()

Injection de @Environment / @EnvironmentObject

Les applications SwiftUI injectent les dépendances via l'environnement, ce qui permet de tester les vues en leur fournissant des objets d'environnement simulés.

let mockStore = MockCartStore()
let view = CartView().environmentObject(mockStore)

Éviter l'excès de mocks

Ne simulez que les dépendances directes : utilisez les collaborateurs réels lorsqu'ils sont déterministes et rapides.

// OK to use real DateFormatter in tests — it's deterministic
// Mock URLSession — network I/O is slow and non-deterministic

Composition de protocoles pour des interfaces plus ciblées

Utilisez des protocoles plus petits et ciblés (principe de ségrégation des interfaces) afin que les mocks n'implémentent que ce qui est nécessaire.

protocol Readable { func read() async throws -> [Item] }
protocol Writable { func write(_ item: Item) async throws }
typealias ReadWrite = Readable & Writable

Vérification rapide

Quel est le principal avantage d'injecter des dépendances via un protocole plutôt qu'un type concret ?

Récapitulatif de la leçon

Définissez un point d'injection fondé sur un protocole pour chaque dépendance. Injectez-la via l'initialiseur. Implémentez des mocks qui enregistrent les appels et renvoient des valeurs de substitution. Simulez les erreurs avec des mocks qui lèvent des erreurs. Vérifiez les interactions avec XCTAssertEqual sur les tableaux d'appels enregistrés.

Questions Fréquemment Posées

La leçon « Simulation fondée sur des protocoles et injection de dépendances » est-elle gratuite ?

Oui — le texte complet de « Simulation fondée sur des protocoles et injection de dépendances » 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 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Simulation fondée sur des protocoles et injection de dépendances » ?

Injecter des doublures de test via des protocoles, sans frameworks de simulation tiers. 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 4.

Combien de temps prend la leçon « Simulation fondée sur des protocoles et injection de dépendances » ?

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. Configuration de XCTestCase, démontage et méthodes de test
  2. Famille XCTAssert et assertions générant des erreurs
  3. Simulation fondée sur des protocoles et injection de dépendances
  4. Tests asynchrones et mesure des performances
← Retour à Swift Academy