Avant de vous montrer comment le trouver et l’utiliser, parlons-en un peu.

Comme vous le savez peut-être, JMeter dispose d’un élément Extracteur Expression régulière dans la catégorie Post-processeurs. La vocation de cet élément Extracteur Expression régulière est d’extraire à partir d’une expression régulière une ou plusieurs chaînes de caractères depuis la réponse reçue d’un échantillon de test. La puissance en termes d’extraction de données de cet élément est très forte, cependant, il est parfois peu aisée de trouver du premier coup la bonne expression régulière qui fera ce que vous voulez. En effet, vous devez jouer et rejouer le scénario pour tester votre expression régulière tant qu’elle n’est pas au point.

C’est là qu’intervient le Testeur de RegExp.

Vous l’avez déjà compris avec son nom, cet élément est un testeur d’expression régulière « au format JMeter ». Ce testeur ne se branche pas sur un échantillon, mais est un type de visualiseur du récepteur Arbre de résultats, ce qui signifie que vous allez pouvoir effectuer des tests d’expression régulière directement sur les résultats d’échantillons se trouvant dans un Arbre de résultats.

Par exemple, si vous avez suivi ce petit billet sur l’enregistrement de votre scénario fonctionnel pour une réutilisation à froid, ou bien que vous avez exécuté une fois votre scénario de test et qu’il y a un problème sur une expression régulière, le tout avec un Arbre de résultats, vous pourrez utiliser le Testeur d’expression régulière (de RegExp) pour créer ou valider votre expression régulière.

La capture d’écran ci-dessous montre le menu permettant d’accéder au testeur depuis un Arbre de résultats.

Ensuite dans le champ Expression régulière, il suffit de saisir son expression régulière (en suivant le format de JMeter, à savoir Jakarta ORO).

Dans l’exemple ci-dessous, l’expression régulière est « debian(.+?).html », signifiant : tout ce qui commence par debian et se termine par .html avec au milieu n’importe quoi. Les parenthèses indiquant que l’on souhaite récupérer ce « n’importe quoi » (dans une variable JMeter dans le cas d’un Extracteur RegExp)

Dans le champ texte de la réponse du Testeur de RegExp, on trouve les éléments de réponses suivants :

Match count: 6
Match[1][0]=debian-squeeze-772.html
Match[1][1]=-squeeze-772.
Match[2][0]=debian-squeeze-772.html
Match[2][1]=-squeeze-772.
Match[3][0]=debian-squeeze-6-0-762.html
Match[3][1]=-squeeze-6-0-762.
Match[4][0]=debian.org/releases/testing/index.fr.html
Match[4][1]=.org/releases/testing/index.fr.
Match[5][0]=debian-squeeze-6-0-762.html
Match[5][1]=-squeeze-6-0-762.
Match[6][0]=debian-squeeze-6-0-762.html
Match[6][1]=-squeeze-6-0-762.

La première ligne signifie qu’il y a eu 6 correspondances trouvées pour l’expression régulière.

Ensuite, on a des groupements « matrice », les correspondances sont indiquées sur deux lignes (ou plus, c’est en fonction du nombre de parenthèses indiquant les sections à récupérer). Pour les lignes 2 et 3 :

• la première donne la chaîne complète de correspondance de l’expression régulière
• la deuxième donnant la valeur voulant être récupérée (le n’importe quoi des parenthèses)

Les lignes suivantes indiquant les autres correspondances en suivant le même modèle.

Si l’élément Testeur de RegExp ne vous donne pas de réponse (écran blanc), c’est qu’il y a un problème dans le format de votre expression régulière.

Si vous êtes satisfait de votre expression régulière, il ne vous reste plus qu’à la copier/coller dans un élément Extracteur Expression régulière.

Pour plus d’aide sur les expressions régulières, j’ai fait les quelques billets suivants :

• Quelques cas d’utilisation de l’extracteur d’expression régulière dans JMeter
• Trouver le bon élément dans une liste avec les expressions régulières et en mode ligne unique

Je profite de ce billet, pour remercier Jean-Louis et Jean-Luc, deux métrologues, qui m’ont suggéré l’idée d’ajouter ce tester d’expression régulière dans JMeter. Et Jean-Louis, de nouveau, pour m’avoir fourni un exemple de code Java avec le moteur d’expression régulière du JDK.

./

Commençons par le plan de test : très simple, une requête avec en élément fils un extracteur d’expression régulière.

La requête HTTP est simplement la page d’accueil de ce blog.

On place un échantillon Débogage après la requête HTTP qui possède l’extracteur d’expression régulière, il permet d’afficher différentes informations internes à JMeter. Ici, on s’intéresse aux valeurs des variables de JMeter.

Ensuite (enfin) vient l’extracteur d’expression régulière, on commence par un « simple ».

Quelques explications :

• Champs réponse à cocher : Corps. La portée de l’extracteur regexp sera le corps de la réponse (le texte html en général)
• Nom de référence : le nom de la variable dans laquelle JMeter va déposer les données récupérée par l’expression régulière
• Expression régulière : ici « (milamber) », qui signifie : « je recherche le mot milamber, et je voudrais récupérer la valeur ». Il n’y a pas à proprement parler d’expression régulière ici, car aucun caractères de correspondance de caractères n’est utilisé (par exemple « * »).
• Canevas : $1$ correspondant au premier « couple » de parenthèses dans l’expression régulière. Donc ici « milamber »
• Correspond au num. : 0. Parmi « tous les milamber » qui vont être trouvés, JMeter en choisi un au hasard et le place dans la variable JMeter NOM_VARIABLE
• Valeur par défaut : correspond à la valeur que va prendre la variable NOM_VARIABLE si jamais l’expression régulière n’est pas trouvée (autrement si il n’y a pas de milamber dans le corps de la réponse)

On exécute (on lance) le test JMeter. Avec le récepteur Arbre de résultats, on peut déjà voir les données de réponse de la page d’accueil de ce site. On voit qu’il y a plusieurs occurrences de « milamber ».

Dans l’échantillon Débogage, dans l’onglet Données de réponse, on retrouve la variable NOM_VARIABLE.

Quelques explications sur les différents « NOM_VARIABLExxx » que l’on trouve.

• NOM_VARIABLE=milamber, correspond bien entendu à la valeur recherchée (et donc trouvée par JMeter) à partir de l’expression régulière
• NOM_VARIABLE_g=1, c’est le nombre de variables $x$ trouvées
• NOM_VARIABLE_g0=milamber, c’est la chaine correspondant à l’expression régulière entière
• NOM_VARIABLE_g1=milamber, correspond à ce qu’a trouvée l’expression régulière dans la partie entre parenthèses

Ici, la variable NOM_VARIABLE_g0 est la même que NOM_VARIABLE_g1 car l’expression régulière est (milamber), et est très simple. Dans le dernier exemple de ce billet, ce n’est pas le cas, voir plus bas.

Changeons l’expression régulière en mettant simplement un M majuscule à Milamber :

Le résultat dans l’échantillon Débogage, c’est « Milamber » en majuscule. Donc l’extracteur d’expression régulière est sensible à la casse.

Changeons l’expression régulière par (Milember), donc volontairement avec une faute.

Ici, comme il n’y a pas de mot Milember dans les données de réponse de la page HTML retournée, la valeur de NOM_VARIABLE est la valeur par défaut (ici le message d’erreur).

Revenons à (milamber) comme expression régulière. Comme je sais qu’il y a plusieurs « milamber » dans la page HTML, et que j’aimerais bien tous les retrouver, on change la valeur du champ Correspond au num par « -1 ». Cette valeur va indiquer à JMeter d’aller chercher toutes les occurrences de l’expression régulière.

Dans la vue données de réponses de l’échantillon Débogage, on a maintenant une suite de NOM_VARIABLE_x où x correspond au numéro de « milamber » trouvé. La variable NOM_VARIABLE se retrouve avec la valeur par défaut.

Quand on regarde à la fin des variables affichées par l’echantillon Débogage, on trouve une variable spéciale NOM_VARIABLE_matchNr = 195. Ce dernier correspond au nombre de « milamber » trouvé.

On a vu que l’extracteur d’expression régulière était sensible à la casse. Pour le rendre « insensible », il suffit de faire précéder l’expression régulière par « (?i) ».

Dans la liste des variables trouvées, on a maintenant à la fois des « milamber » et des « Milamber ».

La dernière expression régulière va indiquer que l’on recherche exclusivement les « milamber » suivi de quelque chose et suivi de « .net ». C’est à dire les milamber dans « milamberspace.net ».

Le « quelque chose » est symbolisé par « .+ »

Le suivi de « .net » est symbolisé par « ?\.net » où la barre oblique inversée (l’anti-slash) sert à désactiver la propriété particulière du point dans une expression régulière.

Dans les résultats, on a donc que les « milamber » dans la chaîne « milamberspace.net ».

Voici pour ce billet montrant quelques cas d’utilisation de l’extracteur d’expression régulière. Bien entendu, ce dernier n’est pas limité à ces cas, il ne tient qu’à vous de faire de belles expressions régulières pour extraire des chaînes à partir des réponses à vos requêtes.

Bonnes regexps !

Deux liens :

• La page du manuel JMeter sur l’extracteur d’expression régulière
• La page du manuel JMeter sur les expressions régulières

./

J’ai mis quelques heures pour trouver cette regexp qui était nécessaire pour la préparation d’un scénario de test de charges JMeter. J’ai même adapté un petit programme Java/Swing testeur de regexp style Java pour qu’il devienne un programme testeur de regexp Jakarta ORO, celui du JMeter, ceci afin de tester plus vite les différentes regexp.

Commençons, soit le texte de réponse d’une requête HTTP (utilisant en fait SOAP/XML-RPC) suivant :

<ClientBean>
<id>765432</id>
<code>1.87665308</code>
<nom>JAMES BOND</nom>
<statutNumAppel>Inactif</statutNumAppel>
</ClientBean>
<ClientBean>
<id>765432</id>
<code>1.33333333</code>
<nom>LARGO WINCH</nom>
<statutNumAppel>Inactif</statutNumAppel>
</ClientBean>
<ClientBean>
<id>765432</id>
<code>1.87999999</code>
<nom>BENGAMIN GATES</nom>
<statutNumAppel>Actif</statutNumAppel>
</ClientBean>
<ClientBean>
<id>765432</id>
<code>1.23334444</code>
<nom>EMMA PEAL</nom>
<statutNumAppel>Inactif</statutNumAppel>
</ClientBean>

Cette liste est dynamique (on n’a pas toujours 4 éléments, celui ayant le statut d’actif n’est pas toujours à cette position (ici 3ème) et les valeurs bien entendues changent pour chaque requête du test).

Comment faire pour extraire le code « 1.87999999 » correspondant au même ID 765432 pour chaque élément de cette liste, et qui est celui « Actif » ? Le tout avec une expression régulière JMeter ?

Avant de commencer, je rappelle que l’analyseur d’expressions régulières de JMeter est Jakarto ORO. Celui-ci fourni un moteur qui reproduit le comportement du moteur d’expressions régulières de Perl v5.003. On peut donc se référer à la documentation de Perl pour comprendre les expressions régulières.

NB. Depuis la version 2.4 de JMeter, le récepteur Arbre de résultats propose une vue Testeur de RegExp qui permet de tester une expression régulière directement sur la réponse de la requête reçue.

Pour revenir à notre question. Tout d’abord, il faut passer en mode ligne unique au niveau de l’analyseur de regexp, pour cela, on utilise un « modificateur » Perl. Un modifier sert à changer le comportement de l’analyseur.

Le modificateur « ligne unique» est à ajouter dans l’expression régulière. Aussi, on place en début de la regexp, la chaîne suivante : « (?s) »

Maintenant, avec le (?s), les caractères de fin de ligne « \n » sont considérés comme n’importe quel caractère, (symbolisé par le point « . » dans une regexp), ce qui signifie que le texte à analyser devient un grand texte d’une seule ligne du point de vue de l’analyseur.

Ensuite la grosse difficulté est que l’on veut le code pour l’élément qui en statutNumAppel à Actif. La première idée de regexp est :

(?s)code>(.+?)</code.+?statutNumAppel>Actif

Malheureusement, cela ne fonctionnera pas, car on se trouve toujours avec le premier ‘code’ (ici 1.87665308). Pourquoi, car le deuxième « .+? » va englober tous les caractères entre la première occurrence du code et le statut Actif.

Pour indiquer à l’analyseur de regexp que l’on veut « le code qui est collé à l’Actif », il faut être un peu plus explicite. Cette regexp sera la bonne (après une bonne cinquantaine de tentative et relecture de la documentation des regexp) :

(?s)(?:>.+?</code.+){0,}>(.+?)</code.+?Actif

Celle-ci indique :

• Avec le (?:>.+?</code.+) on indique un groupement (grâce aux parenthèses) que l’on ne veut pas enregistrer dans une variable $x$ à cause du ?: situé au début.
• Avec {0,} on indique que l’on veut ce groupement (?:>.+?</code.+) de 0 à n fois, l’analyseur doit donc rechercher toutes les occurrences du code.
• Avec le deuxième >(.+?)</code.+ on ‘surprend‘ l’analyseur pour lui dire que finalement on ne veut pas toutes les occurrences, mais les occurrences N – 1 dans le groupement précédent
• Avec le Actif on lui précise que l’on veut l’occurrence N du ‘code’ suivie par le statut Actif.

Et voilà, c’est ‘simple’, une fois que l’on a trouvé…

En complément,

a) JMeter est par défaut en mode multiligne (pour l’avoir explicitement, il faut « (?m) en début d’expression régulière.

b) En mode ligne unique « (?s) », le début de la ligne est représentée par l’accent circonflexe « ^ », et la fin de ligne par le signe dollar « $ »

Pour en savoir plus sur les expressions régulières au niveau JMeter :

• Page d’aide sur les regexp au niveau JMeter
• La page des regexp en Perl, c’est la même syntaxe dans JMeter

Pour tester ses regexp en dehors de JMeter :

• Demonstrateur ORO sur le site de Jakarta ORO

./