Mock delle dipendenze nei test
Sostituisci le implementazioni reali con test double.
Mock delle dipendenze nei test è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.
Mock delle dipendenze nei test
Un mock è un'implementazione fittizia di una dipendenza, utilizzata nei test. Poiché iniettiamo protocolli, possiamo fornire un mock al posto del collaboratore reale.
Un protocollo da simulare
Iniziate da un protocollo che descriva la dipendenza. Sia il tipo reale sia il mock sono conformi a esso.
protocol UserStore {
func name(for id: Int) -> String
}
struct RealStore: UserStore {
func name(for id: Int) -> String { "User-\(id)" }
}
print(RealStore().name(for: 5))Scrittura di un mock
Un mock è conforme al protocollo, ma restituisce valori preimpostati, evitando l'accesso reale alla rete o al disco.
protocol UserStore { func name(for id: Int) -> String }
struct MockStore: UserStore {
func name(for id: Int) -> String { "Mock" }
}
print(MockStore().name(for: 99))Iniezione del mock
Passate il mock al sistema sottoposto a test tramite il suo inizializzatore. Il codice sottoposto a test non può distinguere il mock dalla dipendenza reale.
protocol UserStore { func name(for id: Int) -> String }
struct MockStore: UserStore { func name(for id: Int) -> String { "Mock" } }
struct Profile {
let store: UserStore
func title(_ id: Int) -> String { "Hello, " + store.name(for: id) }
}
print(Profile(store: MockStore()).title(1))Registrazione delle chiamate
Un mock può registrare il modo in cui viene utilizzato, consentendo a un test di verificare che la dipendenza sia stata chiamata correttamente.
protocol Analytics { func track(_ e: String) }
class SpyAnalytics: Analytics {
var events: [String] = []
func track(_ e: String) { events.append(e) }
}
let spy = SpyAnalytics()
spy.track("open")
spy.track("buy")
print(spy.events)Verifica del comportamento
Dopo aver eseguito il codice, controllate i dati registrati. In questo caso verifichiamo che sia stato generato l'evento corretto.
protocol Analytics { func track(_ e: String) }
class Spy: Analytics { var last = ""; func track(_ e: String) { last = e } }
struct Checkout { let analytics: Analytics; func pay() { analytics.track("paid") } }
let spy = Spy()
Checkout(analytics: spy).pay()
print(spy.last == "paid")Definizione dei valori restituiti
Uno stub restituisce valori preimpostati, così è possibile testare la reazione del codice a input specifici.
protocol Clock { func hour() -> Int }
struct StubClock: Clock { let value: Int; func hour() -> Int { value } }
struct Greeter { let clock: Clock; func greet() -> String { clock.hour() < 12 ? "AM" : "PM" } }
print(Greeter(clock: StubClock(value: 9)).greet())
print(Greeter(clock: StubClock(value: 18)).greet())Simulazione degli errori
I mock possono simulare condizioni di errore difficili da provocare con dipendenze reali, migliorando la copertura dei test.
protocol Loader { func load() -> Int? }
struct FailingLoader: Loader { func load() -> Int? { nil } }
struct VM { let loader: Loader; func status() -> String { loader.load() == nil ? "error" : "ok" } }
print(VM(loader: FailingLoader()).status())Test deterministici
Poiché i mock restituiscono valori fissi, i test sono rapidi e deterministici, senza instabilità dovuta ai servizi reali.
protocol Random { func next() -> Int }
struct FixedRandom: Random { func next() -> Int { 42 } }
struct Game { let rng: Random; func roll() -> Int { rng.next() } }
print(Game(rng: FixedRandom()).roll())Nessun framework di test qui
In un progetto reale, queste verifiche si troverebbero nelle asserzioni di XCTest. Il modello di iniezione è identico; cambia solo la sintassi delle asserzioni.
protocol Calc { func add(_ a: Int, _ b: Int) -> Int }
struct RealCalc: Calc { func add(_ a: Int, _ b: Int) -> Int { a + b } }
struct MockCalc: Calc { func add(_ a: Int, _ b: Int) -> Int { 0 } }
print(RealCalc().add(2, 2))
print(MockCalc().add(2, 2))Il ciclo completo
Definire il protocollo, scrivere i tipi conformi reale e mock, iniettare il mock, eseguire il codice e verificare i risultati. La DI rende possibile ogni passaggio.
protocol Repo { func count() -> Int }
struct MockRepo: Repo { func count() -> Int { 3 } }
struct Stats { let repo: Repo; func total() -> Int { repo.count() * 2 } }
print(Stats(repo: MockRepo()).total())Verifica rapida
Che cosa rende possibile simulare una dipendenza con un mock in questo approccio?
Riepilogo
Un mock è conforme al protocollo iniettato e restituisce valori preimpostati, registra le chiamate o simula gli errori. Iniettarlo produce test rapidi e deterministici. Il ciclo è: definire il protocollo, scrivere i tipi conformi reale e mock, iniettare, eseguire il codice e verificare i risultati. Questo completa il corso sulla DI.
Domande Frequenti
La lezione «Mock delle dipendenze nei test» è gratuita?
Sì — il testo completo di «Mock delle dipendenze nei test» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.
Cosa imparerò in «Mock delle dipendenze nei test»?
Sostituisci le implementazioni reali con test double. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Swift Academy?
Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Mock delle dipendenze nei test»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Swift Academy?
Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Perché usare la dependency injection
- Dependency injection tramite inizializzatore
- Astrazioni basate sui protocolli
- Mock delle dipendenze nei test