Swift Academy · Lektion

Abhängigkeiten in Tests mocken

Ersetzen Sie echte Implementierungen durch Test Doubles.

Abhängigkeiten in Tests mocken ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Abhängigkeiten in Tests mocken

Ein Mock ist eine simulierte Implementierung einer Abhängigkeit, die in Tests verwendet wird. Da wir Protokolle injizieren, können wir anstelle der echten abhängigen Komponente einen Mock bereitstellen.

Ein zu mockendes Protokoll

Beginnen Sie mit einem Protokoll, das die Abhängigkeit beschreibt. Sowohl der echte Typ als auch der Mock entsprechen diesem Protokoll.

protocol UserStore {
    func name(for id: Int) -> String
}
struct RealStore: UserStore {
    func name(for id: Int) -> String { "User-\(id)" }
}
print(RealStore().name(for: 5))

Einen Mock schreiben

Ein Mock entspricht dem Protokoll, gibt aber vorgegebene Werte zurück und vermeidet den tatsächlichen Zugriff auf Netzwerk oder Festplatte.

protocol UserStore { func name(for id: Int) -> String }
struct MockStore: UserStore {
    func name(for id: Int) -> String { "Mock" }
}
print(MockStore().name(for: 99))

Den Mock injizieren

Übergeben Sie den Mock über seinen Initializer an das zu testende System. Der getestete Code kann keinen Unterschied feststellen.

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))

Aufrufe protokollieren

Ein Mock kann aufzeichnen, wie er verwendet wurde, sodass ein Test prüfen kann, ob die Abhängigkeit korrekt aufgerufen wurde.

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)

Verhalten überprüfen

Prüfen Sie nach der Ausführung des Codes die aufgezeichneten Daten. Hier überprüfen wir, ob das richtige Ereignis ausgelöst wurde.

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")

Rückgabewerte vorgeben

Ein Stub gibt vorab festgelegte Werte zurück, sodass Sie testen können, wie Ihr Code auf bestimmte Eingaben reagiert.

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())

Fehler simulieren

Mocks können Fehlerbedingungen simulieren, die mit echten Abhängigkeiten nur schwer auszulösen sind, und dadurch die Testabdeckung verbessern.

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())

Deterministische Tests

Da Mocks feste Werte zurückgeben, sind Tests schnell und deterministisch, ohne Unzuverlässigkeit durch echte Dienste.

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())

Hier kein Test-Framework

In einem echten Projekt würden diese Prüfungen in XCTest-Assertions stattfinden. Das Injection-Muster ist identisch; nur die Syntax der Assertions unterscheidet sich.

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))

Der vollständige Ablauf

Definieren Sie ein Protokoll, schreiben Sie echte und simulierte konforme Typen, injizieren Sie den Mock, führen Sie den Code aus und überprüfen Sie das Ergebnis. DI macht jeden dieser Schritte möglich.

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())

Schnelltest

Was macht das Mocking einer Abhängigkeit bei diesem Ansatz möglich?

Zusammenfassung

Ein Mock entspricht dem injizierten Protokoll und gibt vorgegebene Werte zurück, zeichnet Aufrufe auf oder simuliert Fehler. Durch das Injizieren entstehen schnelle, deterministische Tests. Der Ablauf lautet: Protokoll definieren, echte und simulierte konforme Typen schreiben, injizieren, ausführen und überprüfen. Damit ist der DI-Kurs abgeschlossen.

Häufig gestellte Fragen

Ist die Lektion „Abhängigkeiten in Tests mocken“ kostenlos?

Ja — der vollständige Text von „Abhängigkeiten in Tests mocken“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Abhängigkeiten in Tests mocken“?

Ersetzen Sie echte Implementierungen durch Test Doubles. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Abhängigkeiten in Tests mocken“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Swift Academy