Groovy - JSONSlurper

Qu’est-ce que JsonSlurper ? #

JsonSlurper est une classe de Groovy, utilisée pour gérer les fichiers ou les chaînes en format JSON. Elle fait partie du bibliothèque Groovy scripting qui fournit un moyen facile et rapide d’interagir avec le données JSON. JsonSlurper convertit la contenance JSON en une structure de données Groovy, tels que des maps, des listes et des objets, ce qui peut être manipulées et utilisée de manière similaire à n’importe quel autre objet.

Qu’est-ce que le Groovy ? #

Groovy ( https://groovy.apache.org/) est une langue de programmation générale basée sur Java. Elle a été développée comme une alternative plus facile et expressive à Java, conçue pour faciliter l’automatisation des tâches et la intégration avec d’autres langages et plateformes. Groovy offre un syntaxe plus clair et concis que Java, ainsi qu’une multitude de fonctionnalités dynamiques telles que le programme orienté objet, le programme fonctionnel et la programmation meta-programmique. De plus, Groovy peut être exécutée sur le plateau Java sans nécessiter une compilation préalable, ce qui en fait idéal pour les tâches scripturales et d’automatisation. Dans ma opinion, si Java et Python avaient un enfant, cela serait probablement Groovy.

Qu’est-ce que le JSON? #

JSON (JavaScript Object Notation) est une forme de format texte léger et facile à lire pour échanger du données. Il est couramment utilisé pour transmettre des informations entre un client d’une application et un serveur ou entre différentes applications. Le JSON représente les données sous la forme de nœuds et listes de nœuds, et utilise une syntaxe claire et facile à lire basée sur les clés { } pour définir les objets et les parenthèses [ ] pour définir des listes.

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

Comment fonctionne JSONSlurper dans JMeter ? #

JSONSlurper peut être utilisé dans Apache JMeter pour analyser une réponse JSON issue d’une requête HTTP. Voici un exemple de code Groovy illustrant l’utilisation de JSONSlurper dans JMeter :

{
  "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. Nous avons ajouté un post-processeur JSR223 et introduit le code suivant :

import groovy.json.JsonSlurper

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

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

3. Cela renverrait ce qui suit dans le journal 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

L’exemple précédent pourrait être plus simple si nous utilisions un extracteur JSON pour extraire une ou plusieurs valeurs et les stocker en mémoire, comme indiqué dans les images.

Quels autres utilisations pourrait avoir le Slurper JSON dans JMeter? #

Le Slurper JSON est un outil très puissant pour parser et extraire une série de valeurs. Dans l’exemple précédent, c’est facile avec JSONPath, mais cela devient compliqué lorsque nous devons extraire plusieurs valeurs à partir du réponse, car nous aurions dû utiliser un JSONPath pour une valeur provenant de différents nœuds. Dans cet exemple, nous avons plusieurs utilisateurs : John, Peter et Rick. Cela commence à être compliqué.

[{
  "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"
}]

Pour cet exemple, il serait préférable d’enregistrer la réponse entière en mémoire sous forme de variable, puis de récupérer un objet ou un nœud du tableau (nous avons 3 nœuds ou utilisateurs dans le tableau : John, Peter et Rick), puis de récupérer le premier numéro de téléphone pour chaque nœud :

import groovy.json.JsonSlurper

def response = prev.getResponseDataAsString()
vars.put("response",response) //Save the previous JSON response in the response variable
def jsonSlurper = new JsonSlurper()
def json = jsonSlurper.parseText(response) //Process the JSON input in case it needs to be reused.

// -- Examples - //
json.each { //Iterate over the array of nodes
  log.info( it.phoneNumbers[0].toString() ) //Print the value of the first phone number entry
}

D’autres exemples pourraient être l’évaluation de l’âge de l’utilisateur le plus âgé pour obtenir son numéro de téléphone :

def oldestPerson = json.sort{ it.age }[-1] //We sort the array and obtain the last value.
log.info(oldestPerson.name)

Nous pourrions également obtenir l’adresse des personnes qui vivent dans un certain État comme le Texas :

json.each {
  if(it.address.state.equals("TX")){ //We evaluate that the state of residence is Texas
    log.info(it.address.street)
  }
}

Enfin, nous pourrions imprimer tous les e-mails contenant un certain mot-clé :

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

Conclusion #

JSONSlurper est un outil très efficace pour substituer n’importe quel Extracteur JSON pour obtenir plusieurs valeurs ou évaluer les mêmes afin de satisfaire une ou plusieurs critères, ce qui pourrait être très difficile avec une requête JSONPath car nous pouvons utiliser des fonctions natives Groovy. L’environnement et la gestion du contenu dans les nœuds deviennent très simples et hautement scalable, longtemps après avoir développé un critère pour évaluer plusieurs fichiers JSON afin de préserver les espaces, sans l’aide de JSONSlurper qui aurait devenu une problématique très complexe, mais c’est rapide et peut exporter le résultat objet en tant que propriété dans JMeter comme Listes ou Maps, la gestion devient simple et nettement, bien sûr il faut beaucoup d’expérience pour obtenir les résultats attendus. Avez-vous aimé l’article ? À bientôt !