Swift Academy · Aula

Testes de Modelos de View

Teste unitariamente a lógica de apresentação de forma isolada.

Testes de Modelos de View é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Por que testar ViewModels?

O ViewModel contém sua lógica de apresentação, o que faz dele a camada mais valiosa para testes unitários. Como não depende do UIKit nem do SwiftUI, você pode testá-lo isoladamente, de forma rápida e determinística.

Projetado para ser testável

Um ViewModel bem construído recebe suas dependências pelo inicializador. Isso permite que os testes substituam essas dependências por implementações falsas.

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

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

Injeção de dependências

Oculte as dependências concretas atrás de um protocolo. O ViewModel depende da abstração, para que os testes possam injetar um mock.

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

Escrevendo um mock

Um mock está em conformidade com o protocolo e retorna dados predefinidos. Ele permite controlar exatamente o que o ViewModel recebe.

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

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

Um teste unitário básico

Com o mock injetado, você verifica se o ViewModel transforma os dados corretamente.

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

    await vm.load()

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

Testando transições de estado

Os ViewModels geralmente expõem uma enumeração de estado. Teste cada ramo fornecendo as entradas que o produzem.

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

    await vm.load()

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

Testando caminhos de erro

Faça o mock lançar um erro para verificar se o ViewModel trata as falhas de forma adequada e expõe um estado de erro.

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

Verificando interações

Às vezes, é importante verificar se uma dependência foi chamada, e não apenas conferir o resultado. Sinalizadores de espionagem no mock permitem verificar o comportamento.

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

Testando a saída de @Published

Você pode se inscrever em uma propriedade @Published com o Combine para capturar os valores emitidos e verificar a sequência.

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

await vm.load()

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

Mantendo os testes rápidos

Como os mocks retornam imediatamente e não há uma rede real, os testes de ViewModel são executados em milliseconds. Evite temporizadores reais e URLSession — injete também implementações falsas para relógios e agendadores.

Boas práticas

Testes eficazes de ViewModel:

Injetam todas as dependências por meio de protocolos
Testam um comportamento por método de teste
Abrangem caminhos de sucesso, vazio e erro
Verificam as saídas publicadas que a View leria

Verificação rápida

Verifique seus conhecimentos sobre testes de ViewModel.

Resumo

Você aprendeu a testar ViewModels isoladamente:

Injete dependências por trás de protocolos
Use mocks para controlar entradas e observar chamadas
Abranja estados de sucesso, erro e vazio
Verifique as saídas de @Published e as transições de estado

ViewModels testáveis são o resultado da separação de responsabilidades do MVVM.

Perguntas Frequentes

A aula “Testes de Modelos de View” é grátis?

Sim — o texto completo de “Testes de Modelos de View” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Testes de Modelos de View”?

Teste unitariamente a lógica de apresentação de forma isolada. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Testes de Modelos de View”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy