Un doble de prueba es un objeto que toma el lugar de un objeto de producción durante una prueba.
Para que lo entiendas mejor imagina que eres el director de la película Capitán América y el soldado del invierno.
Como director quieres asegurarte de que la pelea entre el Capitán América y el Soldado del invierno cumpla con algunos requisitos que has definido para que esta sea la pelea más épica de todos los tiempos, ¿Cómo harías para comprobarlo?, no vas a ver toda la película si solo quieres validar la pelea que dura unos cuantos minutos, lo más lógico sería que dividieras la película en escenas y te enfocaras en revisar la escena de la pelea, esta será tu prueba unitaria.
Ahora que has definido tu prueba unitaria "la pelea". ¿Cómo harías para probar que la pelea cumpla con los requisitos que has definido?, podrías repetir varias veces la escena hasta que esta cumpla con tus expectativas, sin embargo hay un gran problema con esto, y es que Chris Evans el actor que interpreta el Capitán América te cobra una gran cantidad de dinero por interpretar su papel, si él actúa cada vez que repites la escena para probarla te saldrá demasiado costoso, tú solución es contratar a "Alvarito" el doble del Capitán América, de esta manera Alvarito actuará durante tus pruebas, y solo cuando estés seguro de que la escena cumpla con tus necesidades le dirás a Chris que realice la escena final, así tu costo será mucho más bajo.
Pero, ¿cómo sabe que tiene que hacer durante la pelea tanto Alvarito como Chris o cualquier otro doble?, gracias al libreto del personaje ellos sabrán interpretar correctamente al Capitán América, por esta razón Alvarito puede repetir las veces que sea necesario la escena y solo cuando la apruebes, le dices a Chris que tome el libreto y la realice.
Aquí puedes ver nuestra escena en código de Go:
// Libreto del capitán América, le dice al Actor como actuar en la escena
type LibretoCapi interface {
Pelear()
}
// La Escena requiere de un objeto que sepa interpretar al capitán América,
// es decir que implemente el libreto.
type Escena struct {
CapitanAmerica LibretoCapi
}
// Crea una nueva Escena que contiene al objeto que interpreta al capitán América
func NuevaEscena(c LibretoCapi) Escena {
return Escena{CapitanAmerica: c}
}
// Ejecución de la escena
func (e Escena) Accion() int {
// El capi da 3 golpes y el soldado del invierno 1
e.CapitanAmerica.Pelear()
fmt.Println("golpe soldado del invierno")
e.CapitanAmerica.Pelear()
e.CapitanAmerica.Pelear()
// Retorna el tiempo de duración de la escena, 5 minutos
return 5
}
Ahora que ya sabes que es un doble de prueba, aprenderás a diferenciar los dos tipos de dobles principales que usamos durante el testing: stub y mock.
Usas un doble stub cuando verificas tu prueba sobre la escena, donde Alvarito te ayuda a garantizar que la escena se realice porque él hace parte de esta, por ejemplo si uno de tus requisitos es que la pelea dure exactamente 5 minutos lo puedes comprobar verificando el tiempo de duración de la escena, es decir obtienes la información de tu escena bajo prueba.
Podemos ver que Alvarito hace parte de la escena e interpreta al Capitán América siguiendo el libreto del personaje, además vemos como el director “test” observa la escena de la pelea y sobre esta comprueba si está duró 5 minutos, si llevamos nuestro ejemplo a código podemos escribir una prueba unitaria para comprobar la duración de la escena usando un doble stub:
// Alvarito
type stubCapitanAmerica struct{}
// La interpretación de Alvarito en el papel del capitán América
func (s stubCapitanAmerica) Pelear() {
fmt.Println("golpe capitan America del doble")
}
// La prueba realizada por el director
func Test_Accion(t *testing.T) {
alvarito := stubCapitanAmerica{}
// Creamos una nueva escena en donde actuará alvarito
escena := NuevaEscena(alvarito)
// Ejecutamos la escena
duracion := escena.Accion()
// verificamos si la escena duró 5 minutos con la información que
// nos devuelve la escena
assert.Equal(t, duracion, 5)
}
Usas un doble mock cuando verificas tu prueba sobre el doble y no sobre la escena, donde Alvarito te ayuda a garantizar que la escena se realice porque él hace parte de esta. Por ejemplo si uno de tus requisitos es verificar si la pelea la realiza más cómodamente el Capitán América con el escudo, o quieres saber cuantos movimientos realiza este para ganar la pelea y no lo puedes ver a través de la escena, solo le podrás preguntar a Alvarito para comprobarlo.
Podemos ver que Alvarito hace parte de la escena e interpreta al Capitán América siguiendo el libreto del personaje, además vemos como el director “test” le pregunta a Alvarito información sobre la pelea, si llevamos nuestro ejemplo a código podemos escribir una prueba unitaria para comprobar el número de movimientos de Alvarito usando un doble mock:
// Alvarito
type mockCapitanAmerica struct {
// En este campo alvarito grabará la información de los golpes que realice
cantidadMovimientos int
}
// La interpretación de Alvarito en el papel del capitán América
func (s *mockCapitanAmerica) Pelear() {
// cada vez que se llame el método Pelear, el mock grabará el número
// de movimientos
s.cantidadMovimientos += s.cantidadMovimientos
fmt.Println("golpe capitan America del doble")
}
// La prueba realizada por el director
func Test_Accion(t *testing.T) {
alvarito := &mockCapitanAmerica{}
// Creamos una nueva escena en donde actuará alvarito
escena := NuevaEscena(alvarito)
// Ejecutamos la escena, no nos interesa la duración porque no es lo
// que queremos comprobar en la prueba.
_ = escena.Accion()
// verificamos si el capi realizó 3 movimientos preguntandole a Alvarito
assert.Equal(t, alvarito.cantidadMovimientos, 3)
}
Una vez que nuestras pruebas de la escena pasan, le diremos a Chris que actúe en la escena final.
Así como en la película pagarle a Chris nos generaba un costo alto, debimos usar un doble para probar nuestra escena, y utilizar un libreto para desacoplar la dependencia de Chris, de la misma manera sucede en el código que escribimos, por ejemplo si quisiéramos probar una funcionalidad que dependa de la base de datos sería demasiado costoso y difícil de comprobar si usamos la base de datos directamente en la prueba, así que debemos desacoplar la dependencia con una interfaz (libreto) para no depender de la base de datos (Chris) y usar un doble de prueba (Alvarito) que simule la base de datos e implemente los métodos de la interfaz (libreto), de esta manera podremos usar un doble durante las pruebas y solo en el código de producción usar la base de datos.
A partir de ahora utiliza a Alvarito en tu código y no a Chris.
¿Eres estudiante instituto, colegio o universidad? ¡Tienes 50% de descuento para estudiar en EDteam por todo un año!
