Groovy - JSONSlurper

¿ Qué es JSONSlurper ? #

JSONSlurper es una clase de Groovy, que se utiliza para administrar archivos o strings en formato JSON. Es parte de la biblioteca de scripting de Groovy, que proporciona una forma fácil y rápida de manejar datos JSON. JSONSlurper convierte el contenido JSON en una estructura de datos de Groovy, como mapas, listas y objetos, que se pueden manipular y utilizar de manera similar a cualquier otro objeto.

¿ Qué es Groovy ? #

Groovy es un lenguaje de programación de propósito general basado en Java. Se desarrolló como una alternativa más fácil de usar y más expresiva a Java, y está diseñado para facilitar la automatización de tareas y la integración con otros lenguajes y plataformas. Groovy ofrece una sintaxis más clara y concisa que Java, así como una gran cantidad de características de programación dinámica, como la programación orientada a objetos, la programación funcional y la programación metaprogramable. Además, Groovy se puede ejecutar en la plataforma Java sin requerir compilación previa, lo que lo hace ideal para tareas de scripting y automatización. En mi opinión, si Java y Python tuvieran un hijo, este seguramente seria Groovy.

¿ Qué es JSON ? #

JSON (JavaScript Object Notation) es un formato de texto ligero y fácil de leer para el intercambio de datos. Se utiliza comúnmente para transmitir información entre una aplicación cliente y un servidor o para transmitir datos entre aplicaciones. JSON representa datos en forma de objetos anidados y listas de objetos, y utiliza una sintaxis clara y fácil de leer basada en llaves { } para definir objetos y corchetes [ ] para definir listas.

Las propiedades de un objeto JSON se representan como pares clave y valor { "nombre" : "Juan" } separados por dos puntos : como se puede ver en el siguiente jemplo:

Ejemplo:

{
  "name": "John Doe",
  "age": 35,
  "email": "john.doe@example.com"
}

¿ Cómo funciona JSONSlurper en JMeter ? #

JSONSlurper se puede utilizar en Apache JMeter para parsear una respuesta de una petición HTTP en formato JSON. Aquí hay un ejemplo de código de Groovy que muestra cómo utilizar JSONSlurper en JMeter:

1.- Supongamos que tenemos la siguiente respuesta de tipo JSON, y queremos obtener el primer numero telefónico. Podríamos utilizar un “Dummy sampler” para el ejemplo.

{
  "name": "John Doe",
  "age": 35,
  "address": {
    "street": "123 Main St",
    "city": "Anytown",
    "state": "WA"
  },
  "phoneNumbers": [
    {
      "type": "mobile",
      "number": "555-555-1234"
    },
    {
      "type": "home",
      "number": "555-555-5678"
    },
    {
      "type": "office",
      "number": "555-555-5111"
    },
    {
      "type": "virtual",
      "number": "555-555-3321"
    }
  ],
  "email": "john.doe@example.com"
}

2.- Agregamos un JSR223 Post-processor e introducimos el siguiente código:

import groovy.json.JsonSlurper

def jsonSlurper = new JsonSlurper()
def response = prev.getResponseDataAsString()
def json = jsonSlurper.parseText(response)

log.info(json.phoneNumbers[0].number)

3.- Esto nos devolvería lo siguiente en la bitácora de JMeter:

2021-08-29 16:01:00,972 INFO o.a.j.t.JMeterThread: Thread started: Thread Group 1-1
2021-08-29 16:01:01,969 INFO o.a.j.e.J.JSR223 PostProcessor: 555-555-1234
2021-08-29 16:01:01,970 INFO o.a.j.t.JMeterThread: Thread is done: Thread Group 1-1

El ejemplo anterior pudiera ser más sencillo si utilizamos un JSON extractor para extraer uno o varios valores y ponerlos en memoria, como se muestra en las imágenes.

¿ Qué otros usos pudiera tener JSONSlurper en JMeter? #

JSONSlurper es una herramienta muy poderosa, para parsear y obtener una serie de valores. El ejemplo anterior es sencillo de solucionar con JSONPath, pero esto se empieza a complicar a medida que tenemos que extrar multiples valores de la respuesta, porque tendriamos que utilizar un JSONPath para un valor de los diferentes nodos. Para el siguiente ejemplo tenemos multiples usuarios: John, Peter and Rick. La situación comienza a complicarse.

[{
  "name": "John Doe",
  "age": 35,
  "address": {
    "street": "123 Main St",
    "city": "Anytown",
    "state": "WA"
  },
  "phoneNumbers": [
    {
      "type": "mobile",
      "number": "555-551-1234"
    },
    {
      "type": "home",
      "number": "555-552-5678"
    }
  ],
  "email": "john.doe@example.com"
},{
  "name": "Peter Doe",
  "age": 34,
  "address": {
    "street": "123 Second St",
    "city": "Anytown",
    "state": "TX"
  },
  "phoneNumbers": [
    {
      "type": "mobile",
      "number": "555-553-1234"
    },
    {
      "type": "home",
      "number": "555-554-5678"
    }
  ],
  "email": "peter.doe@example.com"
},{
  "name": "Rick Doe",
  "age": 36,
  "address": {
    "street": "123 Third St",
    "city": "Anytown",
    "state": "NJ"
  },
  "phoneNumbers": [
    {
      "type": "mobile",
      "number": "555-555-1234"
    },
    {
      "type": "home",
      "number": "555-556-5678"
    }
  ],
  "email": "rick.doe@example.com"
}]

Para este ejemplo, lo mejor seria guardar toda la respuesta en memoria como una variable, despues obtener un objecto o nodo del arreglo (tenemos 3 nodos o usuarios en el arreglo John, Peter y Rick), despues obtener el primer número telefónico de cada nodo:

import groovy.json.JsonSlurper

def response = prev.getResponseDataAsString()
vars.put("response",response)				//Guardamos la respuesta anterior tipo JSON en la variable response
def jsonSlurper = new JsonSlurper()
def json = jsonSlurper.parseText(response)	//Procesamos la entrada de tipo JSON, por si es necesario volverla a utilizar.

// -- Ejemplos - //
json.each { 								//Iteramos sobre el arreglo de nodos
  log.info( it.phoneNumbers[0].toString() ) //Imprimer el valor de la primera entrada de numero telefónico
}

Otro ejemplos podrian ser evaluar la edad del usuario más grande para obtener su número telefónico:

def oldestPerson = json.sort{ it.age }[-1]	//Hacemos sort al arreglo y obtenemos el ultimo valor.
log.info(oldestPerson.name)

También podriamos obtener la dirección o domicilio de las personas que vivan en cierto estado como Texas:

json.each { 
	if( it.address.state.equals("TX") ){	//Evaluamos que el estado de residencia sea Texas
		log.info(it.address.street)
	}
}

Finalmente, podriamos imprimir todos los correos electronicos que contengan cierta palabra clave:

json.each { 
	if( it.email.contains("doe") ){
		log.info(it.email)
	}
}

Conclusión #

JSONSlurper es una herramienta muy eficaz para substituir cualquier JSON Extractor para obtener multiples valores o evaluación de los mismos para satisfacer uno o varios criterios, lo cual pudiera ser muy dificil de lograr con JSONPath query, debido a que podemos utilizar funciones nativas de Groovy. El entorno y manejo de la información dentro de los nodos se torna muy sencilla y altamente escalable, hace tiempo desarrollo un criterio para evaluar multiples archivos JSON para reservar espacios, sin la ayuda de JSONslurper eso se hubiera tornado un problema muy complejo, pero dabo que es rápido y se puede exportar el objeto resultante a una propiedad de JMeter como Listas o Mapas, el manejo se torna sencillo y limpio, obviamente hay que practicar bastante para obtener los resultados esperados. Hasta la próxima y espero disfrutes la entrada.