Swift Academy · Lezione

Test dei view model

Esegui unit test sulla logica di presentazione in isolamento.

Test dei view model è 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.

Perché testare i ViewModel?

Il ViewModel contiene la logica di presentazione, perciò è il livello più importante da sottoporre a unit test. Non dipendendo da UIKit o SwiftUI, può essere testato in isolamento, rapidamente e in modo deterministico.

Testabilità fin dalla progettazione

Un ViewModel ben progettato riceve le proprie dipendenze nell'inizializzatore. In questo modo i test possono sostituirle con dei fake.

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

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

Dependency injection

Nasconda le dipendenze concrete dietro un protocollo. Il ViewModel dipende dall'astrazione, così i test possono iniettare un mock.

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

Scrivere un mock

Un mock si conforma al protocollo e restituisce dati predefiniti. Permette di controllare esattamente ciò che il ViewModel riceve.

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

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

Un unit test di base

Dopo aver iniettato il mock, verifichi che il ViewModel trasformi correttamente i dati.

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

    await vm.load()

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

Testare le transizioni di stato

I ViewModel spesso espongono un'enum per rappresentare lo stato. Testi ogni ramo fornendo gli input che lo producono.

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

    await vm.load()

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

Testare i percorsi di errore

Faccia in modo che il mock generi un errore per verificare che il ViewModel gestisca correttamente i problemi e renda disponibile uno stato di errore.

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

Verificare le interazioni

A volte è importante verificare che una dipendenza sia stata chiamata, non solo il risultato. Dei flag di tipo spy nel mock consentono di verificare il comportamento.

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

Testare l'output di @Published

Può sottoscriversi a una proprietà @Published con Combine per acquisire i valori emessi e verificare la sequenza.

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

await vm.load()

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

Mantenere rapidi i test

Poiché i mock restituiscono i risultati immediatamente e non viene utilizzata una rete reale, i test dei ViewModel vengono eseguiti in pochi millisecondi. Eviti i timer reali e URLSession: inietti dei fake anche per gli orologi e gli scheduler.

Buone pratiche

Test efficaci per i ViewModel:

Iniettano tutte le dipendenze tramite protocolli
Verificano un solo comportamento per metodo di test
Coprono i percorsi di successo, di risultato vuoto e di errore
Verificano gli output pubblicati che la View dovrebbe leggere

Verifica rapida

Verifichi le Sue conoscenze sui test dei ViewModel.

Riepilogo

Ha imparato a testare i ViewModel in isolamento:

Iniettare le dipendenze dietro i protocolli
Usare i mock per controllare gli input e verificare le chiamate
Coprite gli stati di successo, di errore e vuoti
Verificare gli output @Published e le transizioni di stato

I ViewModel testabili sono il risultato della separazione delle responsabilità offerta da MVVM.

Domande Frequenti

La lezione «Test dei view model» è gratuita?

Sì — il testo completo di «Test dei view model» è 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 «Test dei view model»?

Esegui unit test sulla logica di presentazione in isolamento. 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 «Test dei view model»?

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

← Torna a Swift Academy