Simulación de dependencias en pruebas
Sustituya las implementaciones reales por dobles de prueba.
Simulación de dependencias en pruebas 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.
Simular dependencias en las pruebas
Un mock es una implementación simulada de una dependencia que se utiliza en las pruebas. Como inyectamos protocolos, podemos proporcionar un mock en lugar del colaborador real.
Un protocolo para simular
Empiece con un protocolo que describa la dependencia. Tanto el tipo real como el mock se ajustan a él.
protocol UserStore {
func name(for id: Int) -> String
}
struct RealStore: UserStore {
func name(for id: Int) -> String { "User-\(id)" }
}
print(RealStore().name(for: 5))Escribir un mock
Un mock se ajusta al protocolo, pero devuelve valores predefinidos, evitando el acceso real a la red o al disco.
protocol UserStore { func name(for id: Int) -> String }
struct MockStore: UserStore {
func name(for id: Int) -> String { "Mock" }
}
print(MockStore().name(for: 99))Inyectar el mock
Pase el mock al sistema en pruebas mediante su inicializador. El código en pruebas no puede notar la diferencia.
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))Registrar llamadas
Un mock puede registrar cómo se utilizó, de modo que una prueba pueda verificar que la dependencia se llamó correctamente.
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)Verificar el comportamiento
Después de ejecutar el código, compruebe los datos registrados. Aquí verificamos que se haya producido el evento correcto.
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")Simular valores de retorno
Un stub devuelve valores preestablecidos para que pueda probar cómo reacciona su código ante entradas concretas.
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())Simular errores
Los mocks pueden simular condiciones de error difíciles de provocar con dependencias reales, lo que mejora la cobertura de las pruebas.
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())Pruebas deterministas
Como los mocks devuelven valores fijos, las pruebas son rápidas y deterministas, sin inestabilidad causada por servicios reales.
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())Aquí no se usa ningún framework de pruebas
En un proyecto real, estas comprobaciones se expresarían mediante aserciones de XCTest. El patrón de inyección es idéntico; solo cambia la sintaxis de las aserciones.
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))El ciclo completo
Defina el protocolo, escriba los tipos conformes real y simulado, inyecte el mock, ejecute el código y verifique el resultado. La DI hace posible cada paso.
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())Comprobación rápida
¿Qué hace posible simular una dependencia con este enfoque?
Resumen
Un mock se ajusta al protocolo inyectado y devuelve valores predefinidos, registra llamadas o simula errores. Al inyectarlo se obtienen pruebas rápidas y deterministas. El ciclo es: definir el protocolo, escribir los tipos conformes real y simulado, inyectar, ejecutar y verificar. Con esto termina el curso de DI.
Preguntas frecuentes
¿La lección «Simulación de dependencias en pruebas» es gratis?
Sí — el texto completo de «Simulación de dependencias en pruebas» 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 «Simulación de dependencias en pruebas»?
Sustituya las implementaciones reales por dobles de prueba. 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 «Simulación de dependencias en pruebas»?
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
- Por qué utilizar inyección de dependencias
- Inyección mediante inicializador
- Abstracciones basadas en protocolos
- Simulación de dependencias en pruebas