Swift Academy · Lektion

View Models testen

Testen Sie Präsentationslogik isoliert mit Unit-Tests.

View Models testen 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.

Warum ViewModels testen?

Das ViewModel enthält Ihre Präsentationslogik und ist daher die wertvollste Schicht für Unit-Tests. Da es keine Abhängigkeit von UIKit oder SwiftUI besitzt, können Sie es schnell und deterministisch isoliert testen.

Von Anfang an testbar

Ein gut aufgebautes ViewModel erhält seine Abhängigkeiten über seinen Initializer. Dadurch können Tests Fakes einsetzen.

final class WeatherViewModel: ObservableObject {
    @Published var temperatureText = ""
    private let service: WeatherService

    init(service: WeatherService) {
        self.service = service
    }
}

Dependency Injection

Verbergen Sie konkrete Abhängigkeiten hinter einem Protokoll. Das ViewModel hängt von der Abstraktion ab, sodass Tests einen Mock injizieren können.

protocol WeatherService {
    func fetchTemperature() async throws -> Double
}

Einen Mock schreiben

Ein Mock entspricht dem Protokoll und liefert vordefinierte Daten zurück. Damit können Sie genau steuern, was das ViewModel sieht.

final class MockWeatherService: WeatherService {
    var stubbedTemperature: Double = 20
    var didCallFetch = false

    func fetchTemperature() async throws -> Double {
        didCallFetch = true
        return stubbedTemperature
    }
}

Ein einfacher Unit-Test

Nachdem der Mock injiziert wurde, prüfen Sie, ob das ViewModel die Daten korrekt transformiert.

func testFormatsTemperature() async {
    let mock = MockWeatherService()
    mock.stubbedTemperature = 25
    let vm = WeatherViewModel(service: mock)

    await vm.load()

    XCTAssertEqual(vm.temperatureText, "25 C")
}

Zustandsübergänge testen

ViewModels stellen häufig ein Zustands-Enum bereit. Testen Sie jeden Zweig, indem Sie die Eingaben auslösen, die zu diesem Zustand führen.

func testLoadingThenLoaded() async {
    let vm = FeedViewModel(service: MockFeedService())
    XCTAssertEqual(vm.state, .loading)

    await vm.load()

    XCTAssertEqual(vm.state, .loaded(["A", "B"]))
}

Fehlerpfade testen

Lassen Sie den Mock einen Fehler auslösen, um zu überprüfen, ob das ViewModel Fehler ordnungsgemäß behandelt und einen Fehlerzustand bereitstellt.

final class FailingService: WeatherService {
    func fetchTemperature() async throws -> Double {
        throw URLError(.notConnectedToInternet)
    }
}

func testShowsErrorOnFailure() async {
    let vm = WeatherViewModel(service: FailingService())
    await vm.load()
    XCTAssertEqual(vm.state, .error)
}

Interaktionen überprüfen

Manchmal ist wichtig, dass eine Abhängigkeit aufgerufen wurde, nicht nur das Ergebnis. Mit Spy-Flags im Mock können Sie das Verhalten überprüfen.

func testFetchIsCalled() async {
    let mock = MockWeatherService()
    let vm = WeatherViewModel(service: mock)
    await vm.load()
    XCTAssertTrue(mock.didCallFetch)
}

@Published-Ausgaben testen

Sie können eine @Published-Eigenschaft mit Combine abonnieren, um ausgegebene Werte aufzuzeichnen und die Sequenz zu überprüfen.

var received: [String] = []
let cancellable = vm.$temperatureText.sink { received.append($0) }

await vm.load()

XCTAssertEqual(received.last, "25 C")
cancellable.cancel()

Tests schnell halten

Da Mocks sofort Ergebnisse liefern und kein echtes Netzwerk verwendet wird, laufen ViewModel-Tests in Millisekunden. Vermeiden Sie echte Timer und URLSession – injizieren Sie auch für Uhren und Scheduler Fakes.

Bewährte Vorgehensweisen

Effektive ViewModel-Tests:

Injizieren alle Abhängigkeiten über Protokolle
Testen ein Verhalten pro Testmethode
Decken Erfolgs-, Leer- und Fehlerpfade ab
Überprüfen veröffentlichte Ausgaben, die die View lesen würde

Kurze Überprüfung

Überprüfen Sie Ihr Wissen über das Testen von ViewModels.

Zusammenfassung

Sie haben gelernt, ViewModels isoliert mit Unit-Tests zu prüfen:

Injizieren Sie Abhängigkeiten hinter Protokollen
Verwenden Sie Mocks, um Eingaben zu steuern und Aufrufe zu überprüfen
Decken Sie Erfolgs-, Fehler- und Leerzustände ab
Überprüfen Sie @Published-Ausgaben und Zustandsübergänge

Testbare ViewModels sind der Lohn für die Trennung von Zuständigkeiten in MVVM.

Häufig gestellte Fragen

Ist die Lektion „View Models testen“ kostenlos?

Ja — der vollständige Text von „View Models testen“ 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 „View Models testen“?

Testen Sie Präsentationslogik isoliert mit Unit-Tests. 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 „View Models testen“?

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