Probar modelos de vista
Pruebe unitariamente la lógica de presentación de forma aislada.
Probar modelos de vista es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.
¿Por qué probar los ViewModels?
El ViewModel contiene la lógica de presentación, por lo que es la capa más valiosa para probar mediante pruebas unitarias. Como no depende de UIKit ni de SwiftUI, puede probarlo de forma aislada, rápida y determinista.
Diseñado para poder probarse
Un ViewModel bien construido recibe sus dependencias mediante el inicializador. Esto permite que las pruebas sustituyan dichas dependencias por fakes.
final class WeatherViewModel: ObservableObject {
@Published var temperatureText = ""
private let service: WeatherService
init(service: WeatherService) {
self.service = service
}
}Inyección de dependencias
Oculte las dependencias concretas detrás de un protocol. El ViewModel depende de la abstracción, por lo que las pruebas pueden inyectar un mock.
protocol WeatherService {
func fetchTemperature() async throws -> Double
}Crear un mock
Un mock se ajusta al protocolo y devuelve datos predefinidos. Permite controlar exactamente lo que ve el ViewModel.
final class MockWeatherService: WeatherService {
var stubbedTemperature: Double = 20
var didCallFetch = false
func fetchTemperature() async throws -> Double {
didCallFetch = true
return stubbedTemperature
}
}Una prueba unitaria básica
Con el mock inyectado, compruebe que el ViewModel transforma los datos correctamente.
func testFormatsTemperature() async {
let mock = MockWeatherService()
mock.stubbedTemperature = 25
let vm = WeatherViewModel(service: mock)
await vm.load()
XCTAssertEqual(vm.temperatureText, "25 C")
}Probar las transiciones de estado
Los ViewModels suelen exponer un enum de estado. Pruebe cada rama proporcionando las entradas que la generan.
func testLoadingThenLoaded() async {
let vm = FeedViewModel(service: MockFeedService())
XCTAssertEqual(vm.state, .loading)
await vm.load()
XCTAssertEqual(vm.state, .loaded(["A", "B"]))
}Probar las rutas de error
Haga que el mock lance un error para verificar que el ViewModel gestiona los fallos correctamente y muestra un estado de error.
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)
}Verificar las interacciones
A veces es importante comprobar que una dependencia fue llamada, no solo verificar el resultado. Los indicadores de tipo spy del mock permiten comprobar el comportamiento.
func testFetchIsCalled() async {
let mock = MockWeatherService()
let vm = WeatherViewModel(service: mock)
await vm.load()
XCTAssertTrue(mock.didCallFetch)
}Probar la salida de @Published
Puede suscribirse a una propiedad @Published con Combine para capturar los valores emitidos y comprobar la secuencia.
var received: [String] = []
let cancellable = vm.$temperatureText.sink { received.append($0) }
await vm.load()
XCTAssertEqual(received.last, "25 C")
cancellable.cancel()Mantener las pruebas rápidas
Como los mocks devuelven los resultados al instante y no hay una red real, las pruebas de ViewModel se ejecutan en milisegundos. Evite los temporizadores reales y URLSession; inyecte también fakes para los relojes y los schedulers.
Buenas prácticas
Las pruebas eficaces de ViewModel:
- Inyectan todas las dependencias mediante protocolos
- Prueban un comportamiento por método de prueba
- Cubren las rutas de éxito, resultado vacío y error
- Comprueban las salidas publicadas que leería la vista
Comprobación rápida
Compruebe sus conocimientos sobre las pruebas de ViewModel.
Resumen
Ha aprendido a probar ViewModels de forma unitaria y aislada:
- Inyectar dependencias detrás de protocolos
- Usar mocks para controlar las entradas y observar las llamadas
- Cubrir los estados de éxito, error y resultado vacío
- Comprobar las salidas
@Publishedy las transiciones de estado
Los ViewModels fáciles de probar son el resultado de separar las responsabilidades en MVVM.
Preguntas frecuentes
¿La lección «Probar modelos de vista» es gratis?
Sí — el texto completo de «Probar modelos de vista» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Probar modelos de vista»?
Pruebe unitariamente la lógica de presentación de forma aislada. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Swift Academy?
No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Probar modelos de vista»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Swift Academy?
Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- El patrón MVVM
- Vincular modelos de vista con vistas
- El patrón Coordinator
- Probar modelos de vista