En este tutorial vamos a ver cómo podemos usar las extensiones de Wiremock para poder generar un servidor de Mocks con respuestas dinámicas.
Índice de contenidos
- 1. Introducción
- 2. Las extensiones de Wiremock
- 3. Plantillas con Handlebars
- 4. Usando la extension para Apache Velocity
- 5. Combinando HandleBars y Velocity
- 6. Conclusiones
1. Introducción
En un tutorial anterior vimos cómo podemos usar Wiremock standalone para poder crear un servidor de mocks de los servicios a los que nos conectamos. Así, podremos aislarnos del estado de los servicios, y basar nuestro desarrollo en una especie de contrato.
Wiremock, básicamente toma un patrón de request de entrada y proporciona una respuesta que normalmente viene expresada en forma de fichero de texto estático que hemos asignado. Pero en ocasiones esto no es suficiente: es posible que queramos dar algo más de sentido a la respuesta, y en vez de tener un carácter estático, que dependa de la request o que se genere a base de fragmentos que se multiplican dentro de un bucle.
Para ello Wiremock cuenta con un mecanismo de extensión para poder crear nuestro propio sistema de salida o usar otros ya existentes. En este tutorial veremos cómo usar las extensiones de Handlebars y de las conocidas plantillas de Apache Velocity.
2. Las extensiones de Wiremock
En ocasiones es necesario que la respuesta obtenida en Wiremock tenga cierto dinamismo para simular las condiciones reales. No estamos hablando de implementar la lógica del servidor al cual sustituímos, pero sí de cambiar un poco la respuesta. Imaginemos casos como:
- Cada respuesta tiene un identificador único.
- Una parte de la respuesta reproduce algún parámetro de la query.
- La respuesta tiene que contar con timeStamps…
Al final lo que queremos hacer es imitar las características mínimas que necesita nuestro servicio de la parte servidora.
Wiremock no incluye capacidades para poder realizar este tipo de salidas, pero sí que cuenta con mecanismos de extensión para que puedas crear tus propios plugins y así poder personalizar su comportamiento para casos especiales. Podrás hacer cosas como:
- Tratamiento de parámetros.
- Manipulación total de la respuesta.
- Matchers de las request personalizados.
- O escuchar tráfico HTTP raw.
Puedes consultar los primeros detalles de la extensión de Wiremock en su documentación: http://wiremock.org/docs/extending-wiremock/
Pero para devolver respuestas dinámicas ya tenemos dos extensiones que se encargan de ello, así que podemos ahorrarnos parte del trabajo:
- Las plantillas con Handlebars.
- La extensión para usar Apache Velocity.
3. Plantillas con Handlebars
Handlebars es una librería de plantillas en Javascript que Wiremock incluye de forma nativa para poder crear respuestas dinámicas a partir de la información de la request.
En la documentación oficial de Wiremock puedes ver la sintáxis para las operaciones con la información de la request: http://wiremock.org/docs/response-templating/
¿Cómo lo podemos usar?
En el directorio maps de la versión Wiremock standalone podemos crear o editar un fichero .json del mapping, añadiendo el atributo "transformers" en la respuesta con el valor adecuado:
{
"request": {
"method": "GET",
"url": "/api/handlebars"
},
"response": {
"status": 200,
"bodyFileName": "templateHandlebars.vm",
"transformers": ["response-template"]
}
}
Y en el fichero de template podemos incluir la expresión de Handlebars:
<html>
<body>
<p>The first part of the path was: {{request.path.[0]}}. </p>
</body>
</html>
En la ejecución del servidor debemos usar el parámetro –global-response-templating para que se active el procesamiento de Handlebars:
java -jar wiremock-standalone-2.5.1.jar --global-response-templating
Con esto devolveremos una respuesta como esta cuando un cliente acceda a http://localhost:8080/api/handlebars
The first part of the path was:api
Donde "api" es el primer elemento del path con el que nos han llamado.
Si quieres recoger un parámetro puedes cambiar la plantilla y ampliar:
<html>
<body>
<p>The first part of the path was: {{request.path.[0]}}. </p>
<p>And the value of the "page" parameter was: {{request.query.page}}</p>
</body>
</html>
Ahora podemos probar a llamar con esta URL: http://localhost:8080/api/handlebars?page=2
Supongo que no te habrá funcionado porque en el mapping tienes que cambiar el matching de url por el matching de urlPath:
"request": {
"method": "GET",
"urlPath": "/api/handlebars"
}
Así, podrá atender cualquier petición a ese path, con independencia de los parámetros. El resultado:
And the value of the "page" parameter was: 2
Puedes acceder a más elementos de la petición, como las cabeceras, cookies o el propio body de un POST.
4. Usando la extension para Apache Velocity
Hasta ahora hemos visto el sistema que incorpora Wiremock por defecto: handlebars, pero sólo nos deja acceder a información de las peticiones. En algunos casos nos puede valer, pero en otros quizá querramos más procesamiento.
Wiremock cuenta con la posibilidad de crear extensiones en Java que permiten manipular las respuestas en diferentes momentos del ciclo de vida. Puedes encontrar más información en: http://wiremock.org/docs/extending-wiremock/
Lo que vamos a hacer ahora es aprovechar el trabajo de Adam York, que ha creado una extensión de Wiremock para poder usar plantillas de Apache Velocity en las respuestas, con toda la potencia que esto conlleva. (https://github.com/adamyork/wiremock-velocity-transformer)
En primer lugar podemos descargar la última versión de la librería en su repositorio de GitHub: https://github.com/adamyork/wiremock-velocity-transformer/releases en el caso de este tutorial era la 1.4. Está en dos formas: extensión para usarla si ya tenemos wiremock -wiremock-velocity-transformer-1.4.jar- y versión standalon que no necesita de nada más (wiremock-velocity-transformer-standalone-1.4.jar). Me decantaré por la segunda.
¿Cómo lo usamos?
Muy sencillo: creamos un mapping
{
"request": {
"method": "GET",
"url": "/api/velocity"
},
"response": {
"status": 200,
"bodyFileName": "templatevm.vm",
"transformers": ["body-transformer", "response-template"]
}
}
… y creamos una plantilla con expresiones de Velocity.
<html> <body> #set( $foo = "Velocity" ) #set ($random = $math.getRandom()) Hello $foo this is a random number: $random! </body> </html>
Ejecutamos la versión standalon que nos acabamos de bajar y que lleva Wiremock standalone en su interior:
Y el resultado es el esperado:
Hello Velocity this is a random number: 0.05027841145154954!
Esto es, utiliza la variable "foo" cuyo contenido es "Velocity" y muestra un número aletorio. A partir de aquí eres libre de tunear la respuesta con las expresiones de Velocity que creas conveniente.
5. Combinando HandleBars y Velocity
Hasta la fecha de este tutorial, la versión de Wiremock con Veloctiy contiene en su interior una versión de Wiremock que todavía no tenía activa la funcionalidad de plantillas de Handlebars. Pero no es problema, podemos sobreescribir las clases de Wiremock gracias al sistema de classloaders de Java.
En primer lugar preparamos el mapping:
{
"request": {
"method": "GET",
"url": "/api/velocity"
},
"response": {
"status": 200,
"bodyFileName": "templatevm.vm",
"transformers": ["body-transformer", "response-template"]
}
}
Y preparamos la plantilla:
<html>
<body>
#set( $foo = "Velocity" )
#set ($random = $math.getRandom())
Hello $foo this is a random number: $random!
And the first parameter of the path was: {{request.path.[0]}}
</body>
</html>
Para ejecutarlo esta vez necestaremos de la ayuda del parámetro -cp de Java para explicitar el ClassPath. Esto nos obligará a expecificar la clase de entrada. También hace falta pasar por parámetro la clase de la extensión de Wiremock para Velocity de Adam York:
java -cp "wiremock-standalone-2.5.0.jar:wiremock-velocity-transformer-standalone-1.4.jar" com.github.tomakehurst.wiremock.standalone.WireMockServerRunner --global-response-templating --extensions com.github.adamyork.wiremock.transformer.VelocityResponseTransformer --verbose
El resultado es la combinación de ambos métodos:
Hello Velocity this is a random number: 0.6999034253976487! And the first parameter of the path was: api
He dejado el código de este tutorial en este repo de GitHub: https://github.com/4lberto/wiremock-demo-vel-handlebars
6. Conclusiones
En este tutorial hemos visto cómo podemos, de una forma sencilla, aprovechar dos extensiones de Wiremock para poder dotar de dinamismo a las respuestas que programamos, y así poder dar un uso más amplio a este servidor de Mocks.
Gracias por el articulo, muy útil