jMeter - Guide rapide

Avant d'entrer dans les détails de JMeter, commençons par comprendre quelques jargons associés au test de toute application.

• Performance Test- Ce test définit les meilleures attentes de performances possibles dans une configuration d'infrastructure donnée. Il indique également au début du processus de test si des modifications doivent être apportées avant la mise en production de l'application.

• Load Test - Ce test est essentiellement utilisé pour tester le système sous la charge supérieure pour laquelle il a été conçu pour fonctionner.

• Stress Test - Ce test est une tentative de briser le système en surchargeant ses ressources.

Qu'est-ce que JMeter?

JMeter est un logiciel qui peut effectuer des tests de charge, des tests commerciaux (fonctionnels) axés sur les performances, des tests de régression, etc., sur différents protocoles ou technologies.

Stefano Mazzocchide l'Apache Software Foundation était le développeur original de JMeter. Il l'a écrit principalement pour tester les performances d'Apache JServ (maintenant appelé projet Apache Tomcat). Apache a ensuite repensé JMeter pour améliorer l'interface graphique et ajouter des capacités de test fonctionnel.

JMeter est une application de bureau Java avec une interface graphique qui utilise l'API graphique Swing. Il peut donc fonctionner sur n'importe quel environnement / poste de travail acceptant une machine virtuelle Java, par exemple - Windows, Linux, Mac, etc.

Les protocoles pris en charge par JMeter sont -

• Web - Sites HTTP, HTTPS 'web 1.0' web 2.0 (ajax, flex et flex-ws-amf)

• Services Web - SOAP / XML-RPC

• Base de données via les pilotes JDBC

• Annuaire - LDAP

• Service orienté messagerie via JMS

• Service - POP3, IMAP, SMTP

• Service FTP

Caractéristiques de JMeter

Voici quelques-unes des fonctionnalités de JMeter -

• Étant un logiciel open source, il est disponible gratuitement.

• Il a une interface graphique simple et intuitive.

• JMeter peut effectuer des tests de charge et de performance pour de nombreux types de serveurs - Web - HTTP, HTTPS, SOAP, base de données via JDBC, LDAP, JMS, Mail - POP3, etc.

• C'est un outil indépendant de la plate-forme. Sous Linux / Unix, JMeter peut être appelé en cliquant sur le script shell JMeter. Sous Windows, il peut être appelé en démarrant le fichier jmeter.bat.

• Il prend en charge les composants Swing et légers (le JAR précompilé utilise les packages javax.swing. *).

• JMeter stocke ses plans de test au format XML. Cela signifie que vous pouvez générer un plan de test à l'aide d'un éditeur de texte.

• Son framework multi-threading complet permet l'échantillonnage simultané par de nombreux threads et l'échantillonnage simultané de différentes fonctions par des groupes de threads séparés.

• Il est hautement extensible.

• Il peut également être utilisé pour effectuer des tests automatisés et fonctionnels des applications.

Comment fonctionne JMeter?

JMeter simule un groupe d'utilisateurs envoyant des requêtes à un serveur cible et renvoie des statistiques qui montrent les performances / fonctionnalités du serveur / application cible via des tableaux, des graphiques, etc.

Jetez un œil à la figure suivante qui illustre le fonctionnement de JMeter -

JMeter est un framework pour Java, donc la toute première exigence est d'avoir JDK installé sur votre machine.

Exigence du système

JDK	1.6 ou supérieur.
Mémoire	Aucune exigence minimale.
Espace disque	Aucune exigence minimale.
Système opérateur	Aucune exigence minimale.

Étape 1: Vérifiez l'installation de Java

Tout d'abord, vérifiez si Java est installé sur votre système. Ouvrez votre console et exécutez l'une des opérations suivantesjava commandes basées sur le système d'exploitation sur lequel vous travaillez.

OS	Tâche	Commander
les fenêtres	Ouvrez la console de commande	c: \> java -version
Linux	Ouvrir le terminal de commande	$ java -version
Mac	Terminal ouvert	machine: ~ joseph $ java -version

Si Java est installé sur votre système, vous obtiendrez une sortie appropriée en fonction du système d'exploitation sur lequel vous travaillez.

OS	Production
les fenêtres	version java "1.7.0_25" Environnement d'exécution Java (TM) SE (build 1.7.0_25-b15) VM serveur 64 bits Java HotSpot (TM) (build 23.25-b01, mode mixte)
Linux	version java "1.7.0_25" Environnement d'exécution Java (TM) SE (build 1.7.0_25-b15) VM serveur 64 bits Java HotSpot (TM) (build 23.25-b01, mode mixte)
Mac	version java "1.7.0_25" Environnement d'exécution Java (TM) SE (build 1.7.0_25-b15) VM serveur 64 bits Java HotSpot (TM) (build 23.25-b01, mode mixte)

Si Java n'est pas installé, installez le kit de développement logiciel Java (SDK) à partir de www.oracle.com/technetwork/java/javase/downloads/index.html . Nous supposons que Java 1.7.0_25 est la version installée pour ce didacticiel.

Étape 2: définir l'environnement Java

Met le JAVA_HOMEvariable d'environnement pour pointer vers l'emplacement du répertoire de base, où Java est installé sur votre machine. Par exemple -

OS	Production
les fenêtres	Définissez la variable d'environnement JAVA_HOME sur C: \ Program Files \ Java \ jdk1.7.0_25
Linux	export JAVA_HOME = / usr / local / java-current
Mac	export JAVA_HOME = / Bibliothèque / Java / Accueil

Ajoutez l'emplacement du compilateur Java au chemin système.

OS	Production
les fenêtres	Ajoutez la chaîne; C: \ Program Files \ Java \ jdk1.7.0_25 \ bin à la fin de la variable système, Path.
Linux	export PATH = $ PATH: $ JAVA_HOME / bin /
Mac	non requis

Vérifiez l'installation de Java à l'aide de java -version comme expliqué ci-dessus.

Étape 3: Téléchargez JMeter

Téléchargez la dernière version de JMeter sur https://jmeter.apache.org/download_jmeter.cgi. Pour ce didacticiel, nous avons téléchargé apache-jmeter-2.9 et l' avons copié dans le dossier C: \> JMeter.

La structure du répertoire doit ressembler à celle ci-dessous -

• apache-jmeter-2.9
• apache-jmeter-2.9\bin
• apache-jmeter-2.9\docs
• apache-jmeter-2.9\extras
• apache-jmeter-2.9\lib\
• apache-jmeter-2.9\lib\ext
• apache-jmeter-2.9\lib\junit
• apache-jmeter-2.9\printable_docs

Vous pouvez renommer le répertoire parent (c.-à-d. Apache-jmeter-2.9) si vous le souhaitez, mais ne changez aucun des noms de sous-répertoire.

Étape 4: Exécutez JMeter

Après avoir téléchargé JMeter, accédez au répertoire bin . Dans ce cas, c'est/home/manisha/apache-jmeter-2.9/bin. Cliquez maintenant sur ce qui suit -

OS	Production
les fenêtres	jmeter.bat
Linux	jmeter.sh
Mac	jmeter.sh

Après une courte pause, l'interface graphique JMeter devrait apparaître, qui est une application Swing, comme le montre la capture d'écran suivante -

Ceci est la page principale et la page par défaut de l'outil.

Qu'est-ce qu'un plan de test?

Un plan de test peut être considéré comme un conteneur pour l'exécution de tests. Il définit ce qu'il faut tester et comment s'y prendre. Un plan de test complet se compose d'un ou plusieurs éléments tels que des groupes de threads, des contrôleurs logiques, des contrôleurs de génération d'échantillons, des écouteurs, des minuteries, des assertions et des éléments de configuration. Un plan de test doit avoir au moins un groupe de threads.

Rédaction d'un plan de test

Suivez les étapes ci-dessous pour rédiger un plan de test -

Étape 1: Démarrez la fenêtre JMeter

Ouvrez la fenêtre JMeter en cliquant sur /home/manisha/apache-jmeter-2.9/bin/jmeter.sh. La fenêtre JMeter apparaîtra comme ci-dessous -

Il s'agit d'une fenêtre JMeter simple et vierge sans aucun élément supplémentaire ajouté. Il contient deux nœuds -

• Test Plan node - c'est là que le vrai plan de test est conservé.

• Workbench node- Il fournit simplement un emplacement pour stocker temporairement les éléments de test lorsqu'ils ne sont pas utilisés, à des fins de copier / coller. Lorsque vous enregistrez votre plan de test, les éléments de Workbench ne sont pas enregistrés avec lui.

Étape 2: Ajouter / supprimer des éléments

Les éléments (qui seront abordés dans le chapitre suivant Eléments du plan de test ) peuvent être ajoutés à un plan de test en cliquant avec le bouton droit sur le nœud Plan de test et en choisissant un nouvel élément dans la liste «ajouter».

Vous pouvez également charger un élément à partir d'un fichier et l'ajouter en choisissant l'option "fusionner" ou "ouvrir".

Par exemple, ajoutons un élément Thread Group à un plan de test comme indiqué ci-dessous -

Pour supprimer un élément, assurez-vous que l'élément est sélectionné, cliquez avec le bouton droit sur l'élément et choisissez l'option "supprimer".

Étape 3: Charger et enregistrer les éléments

Pour charger un élément à partir d'un fichier -

• Cliquez avec le bouton droit sur l'élément d'arborescence existant auquel vous souhaitez ajouter l'élément chargé.
• Sélectionnez Fusionner.
• Choisissez le fichier dans lequel vous avez enregistré les éléments.
• JMeter fusionnera les éléments dans l'arborescence.

Par défaut, JMeter n'enregistre pas l'élément, vous devez l'enregistrer explicitement.

Pour enregistrer les éléments de l'arborescence -

• Faites un clic droit sur l'élément.
• Choisissez l' option Enregistrer la sélection sous ...

JMeter enregistrera l'élément sélectionné, ainsi que tous les éléments enfants en dessous. Par défaut, JMeter n'enregistre pas les éléments, vous devez l'enregistrer explicitement comme mentionné précédemment.

Étape 4: Configuration des éléments de l'arborescence

Tout élément du plan de test peut être configuré à l'aide des commandes présentes dans le cadre de droite de JMeter. Ces contrôles vous permettent de configurer le comportement de cet élément de test particulier. Par exemple, le groupe de threads peut être configuré pour un certain nombre d'utilisateurs, des périodes de montée en puissance, etc., comme indiqué ci-dessous -

Étape 5: Enregistrer le plan de test

Vous pouvez enregistrer un plan de test entier en utilisant soit Save ou "Save Test Plan As ..." dans le menu Fichier.

Étape 6: Exécutez le plan de test

Vous pouvez exécuter le plan de test en cliquant sur Start(Ctrl + r) depuis le Runélément du menu. Lorsque JMeter commence à s'exécuter, il affiche une petite boîte verte à l'extrémité droite de la section juste sous la barre de menus.

Les nombres à gauche de la case verte correspondent au nombre de threads actifs / nombre total de threads. Celles-ci s'appliquent uniquement à un test exécuté localement; ils n'incluent aucun thread démarré sur des systèmes distants lors de l'utilisation du mode client-serveur.

Étape 7: Arrêtez le plan de test

Vous pouvez arrêter votre test de deux manières -

• En utilisant Stop(Contrôle + '.'). Il arrête les threads immédiatement si possible.

• En utilisant Shutdown(Contrôle + ','). Il demande aux threads de s'arrêter à la fin de tout travail en cours.

Un plan de test JMeter comprend les éléments de test décrits ci-dessous. Un plan de test comprend au moins un groupe de threads. Dans chaque groupe de threads, nous pouvons placer une combinaison d'un ou de plusieurs autres éléments - Sampler, Logic Controller, Configuration Element, Listener et Timer. Chaque échantillonneur peut être précédé d'un ou plusieurs éléments de pré-processeur, suivis par un élément de post-processeur et / ou un élément d'assertion. Voyons chacun de ces éléments en détail -

Groupe de threads

Les éléments du groupe de threads sont les points de départ de votre plan de test. Comme son nom l'indique, les éléments du groupe de threads contrôlent le nombre de threads que JMeter utilisera pendant le test. Nous pouvons également contrôler les éléments suivants via le Thread Group -

• Définition du nombre de threads

• Réglage du temps de montée

• Définition du nombre d'itérations de test

Le panneau de configuration du groupe de threads ressemble à ceci:

Le panneau du groupe de threads contient les composants suivants -

• Action to be taken after a Sampler error - En cas d'erreur lors de l'exécution du test, vous pouvez laisser le test soit -

  • Continue à l'élément suivant du test

  • Stop Thread pour arrêter le thread en cours.

  • Stop Test complètement, au cas où vous voudriez inspecter l'erreur avant qu'elle ne continue à s'exécuter.

• Number of Threads - Simule le nombre d'utilisateurs ou de connexions à votre application serveur.

• Ramp-Up Period Définit le temps nécessaire à JMeter pour exécuter tous les threads.

• Loop Count - Définit le nombre d'exécutions du test.

• Scheduler checkbox - Une fois sélectionnée, la section Configuration du planificateur apparaît en bas du panneau de contrôle.

• Scheduler Configuration - Vous pouvez configurer l'heure de début et de fin d'exécution du test.

Contrôleurs

JMeter a deux types de contrôleurs: les échantillonneurs et les contrôleurs logiques .

Échantillonneurs

Les échantillonneurs permettent à JMeter d'envoyer des types spécifiques de requêtes à un serveur. Ils simulent une demande utilisateur pour une page du serveur cible. Par exemple, vous pouvez ajouter un échantillonneur de requête HTTP si vous devez effectuer un POST, GET ou DELETE sur un service HTTP.

Certains échantillonneurs utiles sont -

• Requête HTTP
• Demande FTP
• Demande JDBC
• Demande Java
• Requête SOAP / XML
• Demandes RPC

La capture d'écran suivante montre un panneau de configuration de l'échantillonneur de requête HTTP -

Contrôleurs logiques

Les contrôleurs logiques vous permettent de contrôler l'ordre de traitement des échantillonneurs dans un thread. Les contrôleurs logiques peuvent modifier l'ordre d'une requête provenant de n'importe lequel de leurs éléments enfants. Quelques exemples sont - Contrôleur ForEach, Contrôleur While, Contrôleur de boucle, Contrôleur IF, Contrôleur d'exécution, Contrôleur entrelacé, Contrôleur de débit et Contrôleur d'exécution unique.

La capture d'écran suivante montre un panneau de commande de contrôleur de boucle -

La liste suivante comprend tous les contrôleurs logiques fournis par JMeter -

• Contrôleur simple
• Contrôleur de boucle
• Un seul contrôleur
• Contrôleur d'entrelacement
• Contrôleur aléatoire
• Contrôleur d'ordre aléatoire
• Contrôleur de débit
• Contrôleur d'exécution
• Si contrôleur
• Pendant que le contrôleur
• Contrôleur de commutateur
• ForEach Controller
• Contrôleur de module
• Inclure le contrôleur
• Contrôleur de transaction
• Contrôleur d'enregistrement

Fragments de test

Un fragment de test est un type spécial d'élément placé au même niveau que l'élément Thread Group. Il se distingue d'un groupe de threads en ce qu'il n'est exécuté que s'il est référencé par un contrôleur de module ou un contrôleur Include_Controller. Cet élément est purement pour la réutilisation du code dans les plans de test.

Les auditeurs

Les écouteurs vous permettent d'afficher les résultats des échantillonneurs sous forme de tableaux, de graphiques, d'arbres ou de texte simple dans certains fichiers journaux. Ils fournissent un accès visuel aux données recueillies par JMeter sur les cas de test lors de l'exécution d'un composant Sampler de JMeter.

Les écouteurs peuvent être ajoutés n'importe où dans le test, y compris directement sous le plan de test. Ils collecteront des données uniquement à partir d'éléments inférieurs ou égaux à leur niveau. La liste suivante comprend tous les écouteurs fournis par JMeter -

• Exemple de configuration d'enregistrement des résultats
• Graphique des résultats complets
• Résultats du graphique
• Visualiseur Spline
• Résultats d'assertion
• Afficher l'arborescence des résultats
• Rapport agrégé
• Afficher les résultats dans le tableau
• Rédacteur de données simple
• Surveiller les résultats
• Graphique de distribution (alpha)
• Graphique agrégé
• Visualiseur de courrier
• Écouteur BeanShell
• Rapport sommaire

Minuteries

Par défaut, un thread JMeter envoie des requêtes sans pause entre chaque échantillonneur. Ce n'est peut-être pas ce que vous voulez. Vous pouvez ajouter un élément timer qui vous permet de définir une période d'attente entre chaque requête.

La liste suivante montre tous les minuteurs fournis par JMeter -

• Minuterie constante
• Minuterie aléatoire gaussienne
• Minuterie aléatoire uniforme
• Minuterie à débit constant
• Minuterie de synchronisation
• Heure JSR223
• Heure BeanShell
• Heure BSF
• Temps aléatoire de Poisson

La capture d'écran suivante montre un panneau de commande à minuterie constante -

Assertions

Les assertions vous permettent d'inclure un test de validation sur la réponse de votre demande faite à l'aide d'un échantillonneur. À l'aide d'assertions, vous pouvez prouver que votre application renvoie les données correctes. JMeter met en évidence lorsqu'une assertion échoue.

La liste suivante comprend toutes les assertions fournies par JMeter -

• Assertion Beanshell
• Assertion BSF
• Comparer l'assertion
• Assertion JSR223
• Assertion de réponse
• Assertion de durée
• Assertion de taille
• Assertion XML
• Assertion BeanShell
• Assertion MD5Hex
• Assertion HTML
• Assertion XPath
• Assertion de schéma XML

La capture d'écran suivante montre un panneau de configuration d'assertion de réponse -

Éléments de configuration

Les éléments de configuration vous permettent de créer des valeurs par défaut et des variables à utiliser par les échantillonneurs. Ils sont utilisés pour ajouter ou modifier les demandes faites par les échantillonneurs.

Ils sont exécutés au début de la portée dont ils font partie, avant les échantillonneurs situés dans le même scope. Par conséquent, un élément de configuration est accessible uniquement de l'intérieur de la branche où il est placé.

La liste suivante comprend tous les éléments de configuration fournis par JMeter -

• Counter
• Configuration de l'ensemble de données CSV
• Valeurs par défaut des requêtes FTP
• Gestionnaire d’autorisations HTTP
• Gestionnaire de cache HTTP
• Gestionnaire de cookies HTTP
• Serveur proxy HTTP
• Valeurs par défaut des requêtes HTTP
• Gestionnaire d'en-tête HTTP
• Valeurs par défaut des requêtes Java
• Configuration du keystore
• Configuration de la connexion JDBC
• Élément de configuration de connexion
• Valeurs par défaut des requêtes LDAP
• Valeurs par défaut des requêtes étendues LDAP
• Configuration de l'échantillonneur TCP
• Variables définies par l'utilisateur
• Élément de configuration simple
• Variable aléatoire

Éléments pré-processeur

Un élément de pré-processeur est quelque chose qui s'exécute juste avant l'exécution d'un échantillonneur. Ils sont souvent utilisés pour modifier les paramètres d'une requête d'échantillonnage juste avant son exécution ou pour mettre à jour des variables qui ne sont pas extraites du texte de la réponse.

La liste suivante comprend tous les éléments de pré-processeur fournis par JMeter -

• Analyseur de lien HTML
• Modificateur de réécriture d'URL HTTP
• Modificateur de paramètre utilisateur HTTP
• Paramètres utilisateur
• Préprocesseur JDBC
• Préprocesseur JSR223
• Paramètres utilisateur RegEx
• Préprocesseur BeanShell
• Préprocesseur BSF

Éléments de post-processeur

Un post-processeur s'exécute après qu'un échantillonneur a terminé son exécution. Cet élément est le plus souvent utilisé pour traiter les données de réponse, par exemple pour récupérer une valeur particulière pour une utilisation ultérieure.

La liste suivante comprend tous les éléments de post-processeur fournis par JMeter -

• Extracteur d'expressions régulières
• Extracteur XPath
• Gestionnaire d'actions de statut de résultat
• Post-processeur JSR223
• Post-processeur JDBC
• Post-processeur BSF
• Extracteur CSS / JQuery
• BeanShell PostProcessor
• Déboguer le postprocesseur

Ordre d'exécution des éléments de test

Voici l'ordre d'exécution des éléments du plan de test -

• Éléments de configuration
• Pre-Processors
• Timers
• Sampler
• Post-processeurs (sauf si SampleResult est nul)
• Assertions (sauf si SampleResult est nul)
• Écouteurs (sauf si SampleResult est nul)

Construisons un plan de test simple qui teste une page Web. Nous écrivons un plan de test dans Apache JMeter afin de pouvoir tester les performances de la page Web affichée par l'URL - www.tutorialspoint.com .

Démarrez JMeter

Ouvrez la fenêtre JMeter en cliquant sur /home/manisha/apache-jmeter-2.9/bin/jmeter.sh. La fenêtre JMeter apparaît comme ci-dessous -

Renommer le plan de test

Remplacez le nom du nœud du plan de test par Exemple de test dans la zone de texte Nom . Vous devez changer le focus sur le nœud Workbench et revenir au nœud Plan de test pour voir le nom se refléter.

Ajouter un groupe de threads

Maintenant, nous ajoutons notre premier élément dans la fenêtre. Nous ajoutons un groupe de threads, qui est un espace réservé pour tous les autres éléments tels que les échantillonneurs, les contrôleurs et les écouteurs. Nous en avons besoin pour pouvoir configurer le nombre d'utilisateurs à simuler.

Dans JMeter, tous les éléments de nœud sont ajoutés à l'aide du menu contextuel.

• Cliquez avec le bouton droit de la souris sur l'élément auquel vous souhaitez ajouter un nœud d'élément enfant.

• Choisissez l'option appropriée à ajouter.

• Cliquez avec le bouton droit sur l'exemple de test (notre plan de test) → Ajouter → Threads (utilisateurs) → Thread Group. Ainsi, le groupe de threads est ajouté sous le nœud Plan de test (exemple de test).

• Nommez le groupe de threads en tant qu'utilisateurs . Pour nous, cet élément signifie que les utilisateurs visitent la page d'accueil de TutorialsPoint.

Ajouter un échantillonneur

Nous devons ajouter un échantillonneur dans notre groupe de threads (utilisateurs). Comme précédemment pour l'ajout d'un groupe de threads, cette fois, nous ouvrirons le menu contextuel du nœud Thread Group (Users) en cliquant avec le bouton droit de la souris et nous ajouterons un échantillonneur de requête HTTP en choisissant Ajouter → Échantillonneur → option de requête HTTP.

Il ajoutera un échantillonneur de requête HTTP vide sous le nœud Thread Group (Users). Configurons cet élément de nœud -

• Name- Nous changerons le nom pour refléter l'action que nous voulons réaliser. Nous l'appellerons commeVisit TutorialsPoint Home Page

• Server Name or IP- Ici, nous devons taper le nom du serveur Web. Dans notre cas c'estwww.tutorialspoint.com. (http: // une partie n'est pas écrite ce n'est que le nom du serveur ou son IP)

• Protocol - Nous garderons ce champ vide, ce qui signifie que nous voulons HTTP comme protocole.

• Path- Nous allons taper le chemin comme / (barre oblique). Cela signifie que nous voulons la page racine du serveur.

Ajouter un auditeur

Nous allons maintenant ajouter un auditeur. Ajoutons View Results Tree Listener sous le nœud Thread Group (User). Cela garantira que les résultats de l'échantillonneur seront disponibles pour être visualisés dans cet élément de nœud Listener.

Pour ajouter un auditeur -

• Ouvrez le menu contextuel

• Cliquez avec le bouton droit sur le groupe de threads (utilisateurs)

• Choisissez l'option Ajouter → Écouteur → Afficher l'arborescence des résultats

Exécutez le plan de test

Maintenant, avec toute la configuration, exécutons le plan de test. Avec la configuration du Thread Group (Users), nous conservons toutes les valeurs par défaut. Cela signifie que JMeter n'exécutera l'échantillonneur qu'une seule fois. C'est similaire à un seul utilisateur, une seule fois.

Ceci est similaire à un utilisateur visitant une page Web via un navigateur, avec l'échantillonneur JMeter. Pour exécuter le plan de test, sélectionnez Exécuter dans le menu et sélectionnez l'option Démarrer.

Apache JMeter nous demande d'enregistrer le plan de test dans un fichier disque avant de démarrer réellement le test. Ceci est important si vous souhaitez exécuter le plan de test plusieurs fois. Vous pouvez opter pour l'exécuter sans enregistrer trop.

Afficher la sortie

Nous avons conservé le paramètre du groupe de threads en tant que thread unique (un seul utilisateur) et boucle pendant 1 fois (exécuté une seule fois), par conséquent, nous obtiendrons le résultat d'une seule transaction dans le View Result Tree Listener.

Les détails du résultat ci-dessus sont -

• La couleur verte en regard du nom Visiter la page d'accueil de TutorialsPoint indique le succès.

• JMeter a stocké tous les en-têtes et les réponses envoyés par le serveur Web et prêt à nous montrer le résultat de plusieurs manières.

• Le premier onglet est Résultats de l'échantillonneur. Il affiche les données JMeter ainsi que les données renvoyées par le serveur Web.

• Le deuxième onglet est Demande, qui affiche toutes les données envoyées au serveur Web dans le cadre de la demande.

Le dernier onglet est Données de réponse. Dans cet onglet, l'écouteur affiche les données reçues du serveur au format texte.

Ceci est juste un simple plan de test qui n'exécute qu'une seule requête. Mais la vraie force de JMeter est d'envoyer la même demande, comme si de nombreux utilisateurs l'envoyaient. Pour tester les serveurs Web avec plusieurs utilisateurs, nous devons modifier les paramètres du groupe de threads (utilisateurs).

Dans ce chapitre, nous verrons comment créer un plan de test simple pour tester le serveur de base de données. Pour nos besoins de test, nous utilisons le serveur de base de données MYSQL. Vous pouvez utiliser n'importe quelle autre base de données pour les tests. Pour l'installation et la création de table dans MYSQL, veuillez consulter le didacticiel MYSQL .

Une fois MYSQL installé, suivez les étapes ci-dessous pour configurer la base de données -

• Créez une base de données avec le nom "tutoriel".

• Créez une table tutorials_tbl .

• Insérez des enregistrements dans tutorials_tbl comme indiqué ci-dessous -

mysql> use TUTORIALS;
Database changed
mysql> INSERT INTO tutorials_tbl 
   ->(tutorial_title, tutorial_author, submission_date)
   ->VALUES
   ->("Learn PHP", "John Poul", NOW());
  
Query OK, 1 row affected (0.01 sec)
mysql> INSERT INTO tutorials_tbl
   ->(tutorial_title, tutorial_author, submission_date)
   ->VALUES
   ->("Learn MySQL", "Abdul S", NOW());
 
Query OK, 1 row affected (0.01 sec)
mysql> INSERT INTO tutorials_tbl
   ->(tutorial_title, tutorial_author, submission_date)
   ->VALUES
   ->("JAVA Tutorial", "Sanjay", '2007-05-06');

Query OK, 1 row affected (0.01 sec)
mysql>

• Copiez le pilote JDBC approprié dans /home/manisha/apache-jmeter-2.9/lib.

Créer un plan de test JMeter

Commençons le JMeter à partir de /home/manisha/apache-jmeter-2.9/bin/jmeter.sh.

Ajouter des utilisateurs

Pour créer un groupe de threads,

• Cliquez avec le bouton droit sur Plan de test.

• Sélectionnez Ajouter → Threads (utilisateurs) → Thread Group.

• Ainsi, le groupe de threads est ajouté sous le nœud Plan de test.

• Renommez ce groupe de threads en tant qu'utilisateurs JDBC .

Nous ne modifierons pas les propriétés par défaut du groupe de threads.

Ajout de requêtes JDBC

Maintenant que nous avons défini nos utilisateurs, il est temps de définir les tâches qu'ils vont effectuer. Dans cette section, spécifiez les requêtes JDBC à exécuter.

• Cliquez avec le bouton droit sur l'élément Utilisateurs JDBC.

• Sélectionner Add → Config Element → JDBC Connection Configuration.

• Configurez les champs suivants (nous utilisons la base de données MySQL appelée tutoriel) -

  • Nom de variable lié au pool. Cela doit identifier la configuration de manière unique. Il est utilisé par l'échantillonneur JDBC pour identifier la configuration à utiliser. Nous l'avons nommé test .

  • URL de la base de données - jdbc: mysql: // localhost: 3306 / tutorial.

  • Classe de pilote JDBC: com.mysql.jdbc.Driver.

  • Nom d'utilisateur: root.

  • Mot de passe: mot de passe pour root.

Les autres champs de l'écran sont laissés par défaut comme indiqué ci-dessous -

Ajoutez maintenant une requête JDBC qui fait référence au pool de configuration JDBC défini ci-dessus. Sélectionnez l'élément Utilisateurs JDBC.

• Cliquez sur le bouton droit de votre souris pour accéder au menu Ajouter

• Sélectionner Add → Sampler → JDBC Request.

• Sélectionnez ce nouvel élément pour afficher son panneau de configuration.

• Modifiez les propriétés comme indiqué ci-dessous -

  • Nom de variable lié au pool. Cela doit identifier de manière unique la configuration. Il est utilisé par l'échantillonneur JDBC pour identifier la configuration à utiliser. Nommé cela comme test .

  • Nom - Apprenez.

  • Entrez le nom du pool - test (comme dans l'élément de configuration).

  • Type de requête - instruction Select.

  • Entrez le champ Chaîne de requête SQL.

Créer un auditeur

Ajoutez maintenant l'élément Listener. Cet élément est chargé de stocker tous les résultats de vos requêtes JDBC dans un fichier et de présenter un modèle visuel des données.

• Sélectionnez l'élément Utilisateurs JDBC

• Ajouter un écouteur Afficher l'arborescence des résultats (Add → Listener → View Results Tree).

Enregistrer et exécuter le plan de test

Enregistrez maintenant le plan de test ci-dessus sous db_test.jmx . Exécutez ce plan de test en utilisantRun → Start option.

Vérifiez la sortie

Dans la dernière image, vous pouvez voir que deux enregistrements sont sélectionnés.

Dans ce chapitre, nous verrons comment tester un site FTP à l'aide de JMeter. Créons un plan de test pour tester le site FTP.

Renommer le plan de test

• Ouvrez la fenêtre JMeter en cliquant sur /home/manisha/apache-jmeter-2.9/bin/jmeter.sh

• Cliquez sur le nœud Plan de test.

• Renommez ce nœud de plan de test en tant que TestFTPSite.

Ajouter un groupe de threads

Ajoutez un groupe de threads, qui est un espace réservé pour tous les autres éléments tels que les échantillonneurs, les contrôleurs et les écouteurs.

• Faites un clic droit sur TestFTPSite (notre plan de test)

• Sélectionnez Ajouter → Threads (utilisateurs) → Thread Group. Le groupe de threads sera ajouté sous le nœud Plan de test (TestFTPSite).

• Modifiez les propriétés par défaut du groupe de threads en fonction de nos tests comme suit -

  • Name - Utilisateurs FTP

  • Number of Threads (Users) - 4

  • Ramp-Up Period - laissez la valeur par défaut de 0 seconde.

  • Loop Count - 1

Ajouter un échantillonneur - Demande FTP

Maintenant que nous avons défini nos utilisateurs, il est temps de définir les tâches qu'ils vont effectuer. Ajoutez des éléments de requête FTP. Nous ajoutons deux éléments de requête FTP, l'un qui récupère un fichier et l'autre qui place un fichier sur le site ftp.

• Sélectionnez l'élément utilisateurs FTP.

• Cliquez avec le bouton droit de la souris pour afficher le menu Ajouter

• Sélectionnez Ajouter → Échantillonneur → Demande FTP.

• Sélectionnez l'élément Demande FTP dans l'arborescence.

• Modifiez les propriétés suivantes comme indiqué ci-dessous -

Les détails suivants sont saisis dans cet élément -

• Name - Demande FTP Get

• Server Name or IP - 184.168.74.29

• Remote File - /home/manisha/sample_ftp.txt

• Local File - sample_ftp.txt

• Sélectionnez obtenir (RETR)

• Username - manisha

• Password - manisha123

Maintenant, ajoutez une autre demande FTP comme ci-dessus et modifiez les propriétés comme indiqué dans la capture d'écran suivante -

Les détails suivants sont saisis dans cet élément -

• Name - Demande FTP Put

• Server Name or IP - 184.168.74.29

• Remote File - /home/manisha/examplefile.txt

• Local File - /home/manisha/work/examplefile.txt

• Sélectionnez put (STOR)

• Username - manisha

• Password - manisha123

Ajouter un auditeur

Le dernier élément que vous devez ajouter à votre plan de test est un auditeur. Cet élément se charge de stocker tous les résultats de vos requêtes FTP dans un fichier et de présenter un modèle visuel des données.

• Sélectionnez l'élément utilisateurs FTP.

• Ajoutez un écouteur Afficher l'arborescence des résultats en sélectionnant Ajouter> Écouteur> Afficher l'arborescence des résultats.

Exécutez le plan de test

Enregistrez maintenant le plan de test ci-dessus sous ftpsite_test.jmx . Exécutez ce plan de test en utilisantRun → Start option.

Afficher la sortie

La sortie suivante peut être vue dans l'écouteur.

Vous pouvez voir que quatre requêtes sont effectuées pour chaque requête FTP et que le test est réussi. Le fichier récupéré pour la demande GET est stocké dans le dossier / bin. Dans notre cas, c'est/home/manisha/apache-jmeter-2.9/bin/. Pour la demande PUT, le fichier est téléchargé sur le chemin/home/manisha/.

Dans ce chapitre, nous allons apprendre à créer un plan de test pour tester un WebService. Pour nos besoins de test, nous avons créé un projet de service Web simple et l'avons déployé localement sur le serveur Tomcat.

Créer un projet de service Web

Pour créer un projet de service Web, nous avons utilisé Eclipse IDE. Écrivez d'abord l'interface de point de terminaison de serviceHelloWorld sous le paquet com.tutorialspoint.ws. Le contenu de HelloWorld.java est le suivant -

package com.tutorialspoint.ws;

import javax.jws.WebMethod;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
import javax.jws.soap.SOAPBinding.Style;

//Service Endpoint Interface
@WebService
@SOAPBinding(style = Style.RPC)

public interface HelloWorld {
   @WebMethod String getHelloWorldMessage(String string);
}

Ce service a une méthode getHelloWorldMessage qui prend un paramètre String.

Ensuite, créez la classe d'implémentation HelloWorldImpl.java sous le paquet com.tutorialspoint.ws.

package com.tutorialspoint.ws;

import javax.jws.WebService;

@WebService(endpointInterface="com.tutorialspoint.ws.HelloWorld")
public class HelloWorldImpl  implements HelloWorld  {
   @Override
   public String getHelloWorldMessage(String myName) {
      return("Hello "+myName+" to JAX WS world");
   }
}

Publions maintenant ce service Web localement en créant l'éditeur Endpoint et exposons le service sur le serveur.

La méthode de publication prend deux paramètres -

• Chaîne d'URL du point de terminaison.

• Objet Implementor, dans ce cas, la classe d'implémentation HelloWorld, qui est exposée en tant que service Web au point de terminaison identifié par l'URL mentionnée dans le paramètre ci-dessus.

Le contenu de HelloWorldPublisher.java est le suivant -

package com.tutorialspoint.endpoint;

import javax.xml.ws.Endpoint;
import com.tutorialspoint.ws.HelloWorldImpl;

public class HelloWorldPublisher {
   public static void main(String[] args) {
      Endpoint.publish("http://localhost:9000/ws/hello", new HelloWorldImpl());
   }
}

Modifiez le contenu web.xml comme indiqué ci-dessous -

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, 
   Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/j2ee/dtds/web-app_2_3.dtd">

<web-app>
   <listener>
      <listener-class>
         com.sun.xml.ws.transport.http.servlet.WSServletContextListener
      </listener-class>
   </listener>
	
   <servlet>
      <servlet-name>hello</servlet-name>
      <servlet-class>com.sun.xml.ws.transport.http.servlet.WSServlet</servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>
	
   <servlet-mapping>
      <servlet-name>hello</servlet-name>
      <url-pattern>/hello</url-pattern>
   </servlet-mapping>
	
   <session-config>
      <session-timeout>120</session-timeout>
   </session-config>
	
</web-app>

Pour déployer cette application en tant que service Web, nous aurions besoin d'un autre fichier de configuration sun-jaxws.xml. Le contenu de ce fichier est le suivant -

<?xml version = "1.0" encoding = "UTF-8"?>
<endpoints
   xmlns = "http://java.sun.com/xml/ns/jax-ws/ri/runtime"
   version = "2.0">
   
   <endpoint name = "HelloWorld" 
      implementation = "com.tutorialspoint.ws.HelloWorldImpl" 
      url-pattern = "/hello"/>
</endpoints>

Maintenant que tous les fichiers sont prêts, la structure des répertoires ressemblera à celle illustrée dans la capture d'écran suivante -

• Créez maintenant un fichier WAR de cette application.

• Choisissez le projet → clic droit → Exporter → fichier WAR.

• Enregistrez ceci sous hello.war fichier sous le webapps dossier du serveur Tomcat.

• Démarrez maintenant le serveur Tomcat.

• Une fois le serveur démarré, vous devriez pouvoir accéder au webservice avec l'URL - http: // localhost: 8080 / hello / hello

Créer un plan de test JMeter

Maintenant, créons un plan de test pour tester le webservice ci-dessus.

Renommer le plan de test

• Ouvrez la fenêtre JMeter en cliquant sur /home/manisha/apache-jmeter2.9/bin/jmeter.sh.

• Cliquez sur le nœud Plan de test.

• Renommez ce nœud de plan de test en tant que WebserviceTest.

Ajouter un groupe de threads

Ajoutez un groupe de threads, qui est un espace réservé pour tous les autres éléments tels que les échantillonneurs, les contrôleurs et les écouteurs.

• Cliquez avec le bouton droit sur WebserviceTest (notre plan de test) → Ajouter → Threads (utilisateurs) → Thread Group. Le groupe de threads sera ajouté sous le nœud Plan de test (WebserviceTest).

• Ensuite, modifions les propriétés par défaut du Thread Group en fonction de nos tests. Les propriétés suivantes sont modifiées -

  • Name - utilisateur du webservice

  • Number of Threads (Users) - 2

  • Ramp-Up Period - laissez la valeur par défaut de 0 seconde.

  • Loop Count - 2

Ajouter un échantillonneur - Requête SOAP / XML-RPC

Maintenant que nous avons défini les utilisateurs, il est temps de définir les tâches qu'ils vont effectuer.

Nous allons ajouter un élément de requête SOAP / XML-RPC -

• Cliquez avec le bouton droit de la souris pour afficher le menu Ajouter.

• Sélectionnez Ajouter → Échantillonneur → Requête SOAP / XML-RPC.

• Sélectionnez l'élément de requête SOAP / XML-RPC dans l'arborescence

• Modifiez les propriétés suivantes comme dans l'image ci-dessous -

• Les détails suivants sont saisis dans cet élément -

  • Name − SOAP/XML-RPC Request

  • URL - http: // localhost: 8080 / bonjour / bonjour? Wsdl

  • Soap/XML-RPC Data - Entrez le contenu ci-dessous

<soapenv:Envelope xmlns:soapenv = "http://schemas.xmlsoap.org/soap/envelope/" 
   xmlns:web = "http://ws.tutorialspoint.com/">
   <soapenv:Header/>
	
   <soapenv:Body>
      <web:getHelloWorldMessage>
         <arg0>Manisha</arg0>
      </web:getHelloWorldMessage>
   </soapenv:Body>
   
</soapenv:Envelope>

Ajouter un auditeur

Le dernier élément que vous devez ajouter à votre plan de test est un auditeur. Cet élément est chargé de stocker tous les résultats de vos requêtes HTTP dans un fichier et de présenter un modèle visuel des données.

• Sélectionnez l'élément utilisateur du service Web.

• Ajoutez un écouteur Afficher l'arborescence des résultats en sélectionnant Ajouter → Écouteur → Afficher l'arborescence des résultats.

Exécutez le plan de test

Enregistrez maintenant le plan de test ci-dessus sous le nom test_webservice.jmx . Exécutez ce plan de test à l'aide de l'option Exécuter → Démarrer.

Afficher la sortie

La sortie suivante peut être vue dans l'écouteur.

Dans la dernière image, vous pouvez voir le message de réponse «Hello Manisha to JAX WS world».

Dans ce chapitre, nous allons apprendre à rédiger un plan de test simple pour tester Java Messaging Service (JMS). JMS prend en charge deux types de messagerie -

• Point-to-Point messaging- La messagerie de file d'attente est généralement utilisée pour les transactions où l'expéditeur attend une réponse. Les systèmes de messagerie sont assez différents des requêtes HTTP normales. Dans HTTP, un seul utilisateur envoie une requête et obtient une réponse.

• Topic messaging- Les messages thématiques sont communément appelés messages pub / sub. La messagerie thématique est généralement utilisée dans les cas où un message est publié par un producteur et consommé par plusieurs abonnés.

Voyons un exemple de test pour chacun d'entre eux. Les pré-requis pour tester JMS sont:

• Nous utilisons Apache ActiveMQ dans l'exemple. Il existe différents serveurs JMS comme IBM WebSphere MQ (anciennement MQSeries), Tibco, etc. Téléchargez à partir des fichiers binaires à partir du site Apache ActiveMQ.

• Décompressez l'archive, accédez au répertoire décompressé et exécutez la commande suivante à partir de la console de commande pour démarrer le serveur ActiveMQ -

.\bin\activemq  start

Vous pouvez vérifier si le serveur ActiveMQ a démarré en visitant l'interface d'administration à l'adresse suivante http://localhost:8161/admin/. S'il demande une authentification, entrez l'ID utilisateur et le mot de passe en tant qu'administrateur . L'écran est similaire à celui illustré ci-dessous -

• Copiez maintenant activemq-all-xxxjar (XXX selon la version) du répertoire décompressé d'ActiveMQ vers /home/manisha/apache-jmeter-2.9/lib.

Avec la configuration ci-dessus, construisons le plan de test pour -

• Plan de test JMS point à point

• Plan de test de sujet JMS

Dans ce chapitre, nous verrons comment créer un plan de test à l'aide de JMeter pour surveiller les serveurs Web. Les utilisations des tests de moniteur sont les suivantes -

• Les moniteurs sont utiles pour les tests de résistance et la gestion du système.

• Utilisé avec les tests de résistance, le moniteur fournit des informations supplémentaires sur les performances du serveur.

• Les moniteurs permettent de voir plus facilement la relation entre les performances du serveur et le temps de réponse côté client.

• En tant qu'outil d'administration système, le moniteur permet de surveiller facilement plusieurs serveurs à partir d'une seule console.

Nous avons besoin de Tomcat 5 ou supérieur pour la surveillance. Pour nos besoins de test, nous surveillerons le serveur Tomcat 7.0.42. Vous pouvez tester n'importe quel conteneur de servlet prenant en charge Java Management Extension (JMX). Écrivons un cas de test pour surveiller le serveur Tomcat. Commençons par configurer notre serveur tomcat.

Configurer le serveur Tomcat

Nous commençons par ouvrir le statut du service Tomcat. Pour ce faire, éditez le fichier de configuration des utilisateurs,<TOMCAT_HOME>/conf/tomcat-users.xml. Ce fichier contient une section tomcat-users (commentée) comme indiqué -

<tomcat-users>

<!--
   <role rolename = "tomcat"/>
   <role rolename = "role1"/>
   <user username = "tomcat" password = "tomcat" roles = "tomcat"/>
   <user username = "both" password = "tomcat" roles = "tomcat,role1"/>
   <user username = "role1" password = "tomcat" roles = "role1"/>
-->

</tomcat-users>

Nous devons changer cette section pour ajouter les rôles d'administrateur, manager, manager-gui et affecter l'utilisateur "admin". Le fichier révisé est le suivant -

<tomcat-users>

   <role rolename = "manager-gui"/>
   <role rolename = "manager-script"/>
   <role rolename = "manager-jmx"/>
   <role rolename = "manager-status"/>
   <user username = "admin" password = "admin" roles = "manager-gui,manager-script,manager-jmx,manager-status"/>

</tomcat-users>

Démarrez maintenant le serveur tomcat <TOMCAT_HOME> /bin/startup.sh pour Linux et <TOMCAT_HOME> /bin/startup.bat pour Windows. Une fois démarré, vérifiez que la supervision Tomcat fonctionne en saisissant le lien suivant dans votre navigateur -

http://localhost:8080/manager/status?XML=true

Une fenêtre d'authentification apparaît dans le navigateur. Entrez le login et le mot de passe tomcat associés (dans notre cas c'est admin). Ensuite, le navigateur affiche l'état d'exécution de Tomcat comme ci-dessous -

À partir de la capture d'écran ci-dessus, nous pouvons noter quelques choses -

• Dans l'URL, notez que XML = true (notez le respect de la casse) permet un affichage net du superviseur Tomcat nécessaire au fonctionnement du JMeter.

• Notez également qu'il existe deux connecteurs par défaut. Le connecteur AJP utilisé en général couplé au module frontal mod_jk Apache HTTPD et au connecteur HTTP qui est couramment utilisé pour un accès direct à Tomcat via le port 8080.

Rédiger un plan de test JMeter

Laissez-nous surveiller le serveur Tomcat en écrivant un plan de test -

Renommer le plan de test

• Ouvrez la fenêtre JMeter en cliquant sur /home/manisha/apache-jmeter2.9/bin/jmeter.sh.

• Cliquez sur le nœud Plan de test.

• Ajoutez un groupe de threads comme expliqué à l'étape suivante.

Ajouter un groupe de threads

• Faites un clic droit sur Test Plan → Add → Threads(Users) → Thread Group. Le groupe de threads sera ajouté sous le nœud Plan de test.

• Modifiez le nombre de boucles pour toujours (ou un grand nombre) afin que suffisamment d'échantillons soient générés.

Gestionnaire d’autorisations HTTP

• Ajoutez HTTP Authorization Manager à l'élément Thread Group en sélectionnant Add → Config element → HTTP Authorization Manager. Cet élément gère l'authentification demandée par le navigateur pour voir l'état du serveur Tomcat.

• Sélectionnez le gestionnaire d'autorisation HTTP.

• Modifiez les détails suivants -

  • Username - admin (selon la configuration dans le fichier tomcat-users.xml)

  • Password - admin (selon la configuration dans le fichier tomcatusers.xml)

  • Les autres champs sont laissés vides.

Ajouter une requête Sampler-HTTP

Maintenant que nous avons défini nos utilisateurs, il est temps de définir les tâches qu'ils vont effectuer. Nous ajoutons un élément de requête HTTP.

• Cliquez avec le bouton droit sur le bouton de la souris pour afficher le menu Ajouter.

• Sélectionnez Ajouter → Échantillonneur → Requête HTTP.

• Ensuite, sélectionnez l'élément HTTP Request dans l'arborescence.

• Modifiez les propriétés suivantes comme dans l'image ci-dessous -

• Les détails suivants sont saisis dans cet élément -

  • Name - État du serveur

  • Server Name or IP - localhost

  • Port - 8080

  • Path - / manager / statut

  • Parameters- Ajoutez un paramètre de requête nommé "XML" en majuscules. Donnez-lui la valeur "true" en minuscules.

  • Optional Tasks - Cochez «Utiliser comme moniteur» au bas de l'échantillonneur.

Ajouter une minuterie constante

Pour demander périodiquement l'état du serveur, ajoutez une minuterie constante qui permettra un intervalle de temps entre chaque demande. Ajoutez une minuterie à ce groupe de fils en sélectionnant Ajouter → Minuterie → Minuterie constante.

Entrez 5000 millisecondes dans la zone Thread Delay . En général, l'utilisation d'intervalles inférieurs à 5 secondes peut ajouter du stress à votre serveur. Découvrez quel est l'intervalle acceptable avant de déployer le moniteur dans votre environnement de production.

Ajouter un auditeur

Le dernier élément que vous devez ajouter à votre plan de test est un auditeur. Nous ajoutons deux types d'auditeurs. Celui qui stocke les résultats dans un fichier et le second qui montre la vue graphique des résultats.

• Sélectionnez l'élément de groupe de threads.

• Ajouter un écouteur Simple Data Writer Ajouter → Listener → Simple Data Writer.

• Spécifiez un répertoire et un nom de fichier du fichier de sortie (dans notre cas, il s'agit de /home/manisha/work/sample.csv)

• Ajoutons un autre auditeur en sélectionnant l'élément du plan de test Add → Listener → Monitor Results.

Exécutez le plan de test

Maintenant, enregistrez le plan de test ci-dessus sous monitor_test.jmx . Exécutez ce plan de test à l'aide de l'option Exécuter → Démarrer.

Afficher la sortie

Les résultats seront enregistrés dans le fichier /home/manisha/work/sample.csv. Vous pouvez également voir un résultat graphique dans l'écouteur de résultats Monitor comme dans l'image ci-dessous.

Notez que le graphique a des légendes des deux côtés du graphique. Sur la gauche se trouve le pourcentage et la droite est mort / sain. Si la ligne de mémoire augmente et diminue rapidement, cela peut indiquer un problème de mémoire. Dans ces situations, il est judicieux de profiler l'application avec Borland OptimizeIt ou JProbe. Ce que vous voulez voir est un modèle régulier pour la charge, la mémoire et les threads. Tout comportement erratique indique généralement des performances médiocres ou un bogue quelconque.

Les écouteurs permettent d'accéder aux informations que JMeter rassemble sur les cas de test pendant l'exécution de JMeter. Les résultats ou informations recueillis par les auditeurs peuvent être présentés sous la forme de -

• tree
• tables
• graphs
• fichier journal

Tous les écouteurs écrivent les mêmes données brutes dans le fichier de sortie lorsque celui-ci est spécifié.

Configuration par défaut

Les éléments par défaut à enregistrer peuvent être définis de l'une des deux manières suivantes -

• dans le jmeter.properties(ou user.properties) fichier. Ce fichier est présent dans le/bin dossier de JMeter.Pour modifier le format par défaut, recherchez la ligne suivante dans jmeter.properties -

jmeter.save.saveservice.output_format=

• En utilisant la fenêtre contextuelle Config comme indiqué dans la capture d'écran suivante -

JMeter crée les résultats d'un test exécuté sous forme de journaux de texte JMeter (JTL). Ceux-ci sont normalement appelés fichiers JTL, car c'est l'extension par défaut - mais n'importe quelle extension peut être utilisée.

Si plusieurs tests sont exécutés en utilisant le même nom de fichier de sortie, JMeter ajoute automatiquement de nouvelles données à la fin du fichier.

L'écouteur peut enregistrer les résultats dans un fichier mais pas dans l'interface utilisateur. Il est destiné à fournir un moyen efficace d'enregistrement des données en éliminant la surcharge de l'interface graphique.

Lors de l'exécution -

• GUI mode - utiliser l'écouteur Simple Data Writer

• non-GUI mode - le drapeau -l peut être utilisé pour créer un fichier de données.

Les auditeurs peuvent utiliser beaucoup de mémoire s'il y a beaucoup d'échantillons. Pour minimiser la quantité de mémoire nécessaire, utilisez le format Simple Data Write with CSV.

Format du journal CSV

Le format du journal CSV dépend des éléments de données sélectionnés dans la configuration. Seuls les éléments de données spécifiés sont enregistrés dans le fichier. L'ordre d'apparition des colonnes est fixe et est le suivant -

Champ	La description	Exemple de valeur
timeStamp	en millisecondes depuis le 1/1/1970	1354223881017
écoulé	en millisecondes	1858
étiquette	étiquette d'échantillonneur	Requête HTTP
Code de réponse	par exemple 200, 404	200
responseMessage	par exemple OK	D'accord
threadName		Groupe de fils 1-1
Type de données	ex. texte	texte
Succès	vrai ou faux	vrai
échecMessage	si seulement
octets	nombre d'octets dans l'échantillon	34908
grpThreads	nombre de threads actifs dans ce groupe de threads	1
toutes les discussions	nombre total de threads actifs dans tous les groupes	1
URL		http://tutorialspoint.com
Nom de fichier	si Enregistrer la réponse dans un fichier a été utilisé
latence	heure de la première réponse	132
codage		utf-8
SampleCount	nombre d'échantillons (1, sauf si plusieurs échantillons sont agrégés)	1
ErrorCount	nombre d'erreurs (0 ou 1, sauf si plusieurs échantillons sont agrégés)	0
Nom d'hôte	où l'échantillon a été généré	Ordinateur portableManisha
Temps d'inactivité	nombre de millisecondes de temps d'inactivité (normalement 0)
Variables	si spécifié

Enregistrement des données de réponse

Les données de réponse peuvent être enregistrées dans le fichier journal XML si nécessaire. Cependant, il ne permet pas de sauvegarder des fichiers et des images volumineux. Dans de tels cas, utilisez le post-processeur Save_Responses_to_a_file. Cela génère un nouveau fichier pour chaque échantillon et enregistre le nom de fichier avec l'exemple. Le nom de fichier peut ensuite être inclus dans la sortie de journal d'exemple. Les données seront extraites du fichier si nécessaire lors du rechargement de l'exemple de fichier journal.

Chargement (lecture) des données de réponse

Pour afficher un fichier de résultats existant, vous pouvez utiliser le bouton "Parcourir ..." du fichier pour sélectionner un fichier. Si nécessaire, créez simplement un plan de test factice avec l'auditeur approprié.

Enregistrement des données de l'interface graphique de l'auditeur

JMeter est capable de sauvegarder n'importe quel écouteur sous forme de fichier PNG. Faire cela,

• Sélectionnez l'auditeur dans le panneau de gauche en sélectionnant Édition → Enregistrer comme image. Une boîte de dialogue de fichier apparaît.

• Saisissez le nom souhaité.

• Sauvegardez l'auditeur.

Fonctions JMeter et variables utilisateur

Les fonctions JMeter sont des valeurs spéciales qui peuvent remplir les champs de n'importe quel échantillonneur ou autre élément d'une arborescence de test.

• Un appel de fonction ressemble à ceci -

${__functionName(var1,var2,var3)}

• _functionName correspond au nom d'une fonction. Par exemple${__threadNum}.

• Si un paramètre de fonction contient une virgule, assurez-vous de l'échapper avec "\" comme indiqué ci-dessous -

${__time(EEE\, d MMM yyyy)}

• Les variables sont référencées comme -

${VARIABLE}

Liste des fonctions

Le tableau suivant répertorie un groupe de fonctions regroupées en types -

Type de fonction	Nom	Commentaire
Information	threadNum	Obtenez le numéro de fil.
Information	samplerName	Obtenez le nom de l'échantillonneur (étiquette).
Information	machineIP	Obtenez l'adresse IP de la machine locale.
Information	nom de la machine	Obtenez le nom de l'ordinateur local.
Information	temps	Renvoie l'heure actuelle dans différents formats.
Information	Journal	Enregistrer (ou afficher) un message (et renvoyer la valeur).
Information	se connecter	Enregistrer (ou afficher) un message (valeur de retour vide).
Contribution	StringFromFile	Lire une ligne dans un fichier.
Contribution	FileToString	Lisez un fichier entier.
Contribution	CSVRead	Lire à partir d'un fichier délimité CSV.
Contribution	XPath	Utilisez une expression XPath pour lire à partir d'un fichier.
Calcul	compteur	Générez un nombre incrémentiel.
Calcul	intSum	Ajoutez des nombres int.
Calcul	longSum	Ajoutez des nombres longs.
Calcul	Aléatoire	Générez un nombre aléatoire.
Calcul	RandomString	Générez une chaîne aléatoire.
Calcul	UUID	Générez un UUID de type 4 aléatoire.
Scripting	BeanShell	Exécutez un script BeanShell.
Scripting	javaScript	Processus JavaScript (Mozilla Rhino).
Scripting	jexl, jexl2	Évaluez une expression Jexl Commons.
Propriétés	propriété	Lire une propriété.
Propriétés	P	Lire une propriété (méthode abrégée).
Propriétés	setProperty	Définissez une propriété JMeter.
Variables	Divisé	Divisez une chaîne en variables.
Variables	V	Évaluez un nom de variable.
Variables	évaluer	Évaluez une expression variable.
Variables	evalVar	Évaluez une expression stockée dans une variable.
Chaîne	regexFunction	Analyser la réponse précédente à l'aide d'une expression régulière.
Chaîne	escapeOroRegexpChars	Cite les méta caractères utilisés par l'expression régulière ORO.
Chaîne	carboniser	Générez des valeurs de caractères Unicode à partir d'une liste de nombres.
Chaîne	unescape	Traitez les chaînes contenant des échappements Java (par exemple \ n & \ t).
Chaîne	unescapeHtml	Décodez les chaînes encodées en HTML.
Chaîne	escapeHtml	Encodez les chaînes à l'aide du codage HTML.
Chaîne	TestPlanName	Renvoie le nom du plan de test actuel.

• Il existe deux types de fonctions -

  • Valeurs statiques (ou variables) définies par l'utilisateur

  • Fonctions intégrées

• Les valeurs statiques définies par l'utilisateur permettent à l'utilisateur de définir des variables à remplacer par leur valeur statique lorsqu'un arbre de test est compilé et soumis à l'exécution.

• Les variables ne peuvent pas être imbriquées; c'est à dire${Var${N}} ne marche pas.

• La fonction __V (variable) (versions après 2.2) peut être utilisée pour cela - $ {__ V (Var $ {N})}.

• Ce type de remplacement est possible sans fonctions, mais il est moins pratique et moins intuitif.

Où utiliser les fonctions et les variables

Les fonctions et les variables peuvent être écrites dans n'importe quel champ de n'importe quel composant de test.

Les fonctions suivantes devraient bien fonctionner dans un plan de test -

• intSum
• longSum
• machineName
• BeanShell
• javaScript
• jexl
• random
• time
• fonctions de propriété
• fonctions de journalisation

Les fonctions utilisées dans le plan de test comportent certaines restrictions. Les variables de thread JMeter n'auront pas été entièrement configurées lorsque les fonctions sont traitées, donc les noms de variables passés en tant que paramètres ne seront pas définis et les références de variables ne fonctionneront pas. Par conséquent, split () et regex () et les fonctions d'évaluation des variables ne fonctionneront pas. La fonction threadNum () ne fonctionnera pas et n'a aucun sens au niveau du plan de test.

Référencer des variables et des fonctions

• Le référencement d'une variable dans un élément de test se fait en mettant entre parenthèses le nom de la variable avec '$ {' et '}'.

• Les fonctions sont référencées de la même manière, mais par convention, les noms des fonctions commencent par «__» pour éviter tout conflit avec les noms de valeurs utilisateur.

• Certaines fonctions prennent des arguments pour les configurer, et ceux-ci sont placés entre parenthèses, séparés par des virgules. Si la fonction ne prend aucun argument, les parenthèses peuvent être omises. Par exemple -

${__BeanShell(vars.put("name"\,"value"))}

• Alternativement, vous pouvez définir votre script en tant que variable, par exemple sur le plan de test -

SCRIPT     vars.put("name","value")

• Le script peut alors être référencé comme suit -

${__BeanShell(${SCRIPT})}

La boîte de dialogue d'aide aux fonctions

La boîte de dialogue Function Helper est disponible à partir de JMeter Options languette.

• À l'aide de l'aide aux fonctions, vous pouvez sélectionner une fonction dans le menu déroulant et affecter des valeurs à ses arguments. La colonne de gauche du tableau fournit une brève description de l'argument et la colonne de droite est l'endroit où vous écrivez la valeur de cet argument. Différentes fonctions prennent des arguments différents.

• Une fois que vous avez fait cela, cliquez sur le bouton «Générer», et la chaîne appropriée est générée, que vous pouvez copier-coller dans le plan de test partout où vous en avez besoin.

Variables prédéfinies

Certaines variables sont définies en interne par JMeter. Ils sont -

• COOKIE_cookiename - contient la valeur du cookie.

• JMeterThread.last_sample_ok - que le dernier échantillon soit OK ou non - vrai / faux. Remarque - ceci est mis à jour après l'exécution des PostProcessors et des Assertions.

• Variables START.

Propriétés prédéfinies

Certaines propriétés intégrées sont définies par JMeter. Ceux-ci sont énumérés ci-dessous. Pour plus de commodité, les propriétés START sont également copiées dans des variables portant les mêmes noms.

• START.MS - Heure de début de JMeter en millisecondes.

• START.YMD - Heure de début JMeter au format aaaaMMjj.

• START.HMS - Heure de début de JMeter comme HHmmss.

• TESTSTART.MS - heure de début du test en millisecondes.

Notez que les variables / propriétés START représentent l'heure de démarrage de JMeter, pas l'heure de début du test. Ils sont principalement destinés à être utilisés dans les noms de fichiers, etc.

Les expressions régulières sont utilisées pour rechercher et manipuler du texte, sur la base de modèles. JMeter interprète les formes d'expressions régulières ou de modèles utilisés tout au long d'un plan de test JMeter, en incluant le logiciel de correspondance de modèles Apache Jakarta ORO .

Avec l'utilisation d'expressions régulières, nous pouvons certainement gagner beaucoup de temps et obtenir une plus grande flexibilité lorsque nous créons ou améliorons un plan de test. Les expressions régulières fournissent une méthode simple pour obtenir des informations à partir de pages lorsqu'il est impossible ou très difficile de prédire un résultat.

Un exemple d'utilisation standard d'expressions consiste à obtenir un ID de session à partir de la réponse du serveur. Si le serveur renvoie une clé de session unique, nous pouvons facilement l'obtenir en utilisant les expressions de notre script de chargement.

Pour utiliser des expressions régulières dans votre plan de test, vous devez utiliser l'extracteur d'expressions régulières de JMeter. Vous pouvez placer des expressions régulières dans n'importe quel composant d'un plan de test.

Il convient de souligner la différence entre contains et matches, tel qu'utilisé sur l'élément de test d'assertion de réponse -

• containssignifie que l'expression régulière correspond à au moins une partie de la cible, donc "alphabet" "contient" "ph.b." car l'expression régulière correspond à la sous-chaîne «phabe».

• matchessignifie que l'expression régulière correspond à l'ensemble de la cible. Par conséquent, «l'alphabet» est «mis en correspondance» par «al. * T».

Supposons que vous souhaitiez faire correspondre la partie suivante d'une page Web -

name = "file" value = "readme.txt"

Et vous voulez extraire readme.txt. Une expression régulière appropriée serait -

name = "file" value = "(.+?)">

Les caractères spéciaux ci-dessus sont -

• ( et ) - ceux-ci entourent la partie de la chaîne de correspondance à renvoyer

• . - correspond à n'importe quel caractère

• + - une ou plusieurs fois

• ? - arrêter quand le premier match réussit

Créer un plan de test JMeter

Laissez-nous comprendre l'utilisation des expressions régulières dans l'extracteur d'expressions régulières - un élément de post-processeur en écrivant un plan de test. Cet élément extrait le texte de la page actuelle à l'aide d'une expression régulière pour identifier le modèle de texte auquel un élément souhaité se conforme.

Nous écrivons d'abord une page HTML contenant une liste de personnes et leurs identifiants de messagerie. Nous le déployons sur notre serveur tomcat. Le contenu de html (index.html) est le suivant -

<html>
   <head>
   </head>
	
   <body>
      <table style = "border: 1px solid #000000;">
		
         <th style = "border: 1px solid #000000;">ID</th>
         <th style = "border: 1px solid #000000;">name</th>
         <th style = "border: 1px solid #000000;">Email</th>
			
         <tr>
            <td id = "ID" style = "border: 1px solid #000000;">3</td>
            <td id = "Name" style = "border: 1px solid #000000;">Manisha</td>
            <td id = "Email" style = "border: 1px solid #000000;">[email protected]</td>
         </tr>
			
         <tr>
            <td id = "ID" style = "border: 1px solid #000000;">4</td>
            <td id = "Name" style = "border: 1px solid #000000;">joe</td>
            <td id = "Email" style = "border: 1px solid #000000;">[email protected]</td>
         </tr>
			
      </table>
   </body>
</html>

En le déployant sur le serveur tomcat, cette page ressemblerait à celle illustrée dans la capture d'écran suivante -

Dans notre plan de test, nous sélectionnerons la personne dans la première ligne du tableau des personnes dans la page de liste des personnes ci-dessus. Pour capturer l'ID de cette personne, nous allons d'abord déterminer le modèle où nous trouverons la personne dans la deuxième ligne.

Comme on peut le voir dans l'instantané suivant, l'ID de la deuxième personne est entouré de <td id = "ID"> et </ td>, et c'est la deuxième ligne de données ayant ce modèle. Nous pouvons l'utiliser pour correspondre au modèle exact dont nous voulons extraire les informations. Comme nous voulons extraire deux informations de cette page, l'ID de la personne et le nom de la personne, les champs sont définis comme suit -

Démarrez JMeter, ajoutez un groupe de threads Test Plan → Add→ Threads(Users)→ Thread Group.

Ensuite, ajoutez une requête HTTP d'échantillonneur, sélectionnez le plan de test, faites un clic droit Add → Sampler → HTTP Request et entrez les détails comme indiqué ci-dessous -

• Name - Gérer

• Server Name or IP - localhost

• Port Number - 8080

• Protocol - Nous garderons ce champ vide, ce qui signifie que nous voulons HTTP comme protocole.

• Path - jmeter / index.html

Ensuite, ajoutez un extracteur d'expressions régulières. Sélectionnez l'échantillonneur de requête HTTP (Gérer), faites un clic droitAdd → Post Processor → Regular Expression Extractor.

Le tableau suivant fournit une description des champs utilisés dans la capture d'écran ci-dessus -

Sr.Non	Champ et description
1	Reference Name Le nom de la variable dans laquelle le test extrait sera stocké (refname).
2	Regular Expression Le modèle par rapport auquel le texte à extraire sera mis en correspondance. Les groupes de texte qui seront extraits sont encadrés par les caractères '(' et ')'. Nous utilisons ". +?" pour indiquer une seule instance du texte entre les balises <td ..> .. </td>. Dans notre exemple, l'expression est - <td id = "ID"> (+?) </td> \ s * <td id = "Name"> (+?) </td> \ s *
3	Template Chaque groupe de texte extrait est placé en tant que membre de la variable Personne, en suivant l'ordre de chaque groupe de motif entouré par '(' et ')'. Chaque groupe est stocké sous le nom refname_g #, où refname est la chaîne que vous avez entrée comme nom de référence et # est le numéro du groupe. $ 1 $ to fait référence au groupe 1, $ 2 $ to se réfère au groupe 2, etc. $ 0 $ fait référence à ce que l'expression entière correspond. Dans cet exemple, l'ID que nous extrayons est conservé dans Person_g1, tandis que la valeur Name est stockée dans Person_g2.
4	Match No. Puisque nous prévoyons d'extraire seulement la deuxième occurrence de ce modèle, correspondant au deuxième volontaire, nous utilisons la valeur 2. La valeur 0 ferait une correspondance aléatoire, tandis qu'une valeur négative doit être utilisée avec le contrôleur ForEach.
5	Default Si l'élément n'est pas trouvé, ce sera la valeur par défaut. Ce champ n'est pas obligatoire. Vous pouvez le laisser vide.

Ajoutez un écouteur pour capturer le résultat de ce plan de test. Cliquez avec le bouton droit sur le groupe de threads et sélectionnez l'option Ajouter → Écouteur → Afficher l'arborescence des résultats pour ajouter l'écouteur.

Enregistrez le plan de test sous reg_express_test.jmx et exécutez le test. La sortie serait un succès comme indiqué dans la capture d'écran suivante -

JMeter présente certaines limitations, en particulier lorsqu'il est exécuté dans un environnement distribué. Suivre ces directives aidera à créer une charge réelle et continue -

• Utilisez plusieurs instances de JMeter au cas où, le nombre de threads serait supérieur.

• Vérifiez les règles de portée et concevez en conséquence.

• Utilisez toujours les conventions de dénomination pour tous les éléments.

• Vérifiez les paramètres de connectivité par défaut du navigateur avant d'exécuter des scripts.

• Ajoutez des auditeurs de manière appropriée.

• Voici quelques suggestions pour réduire les besoins en ressources -

• Utilisez le mode non-GUI: jmeter -n -t test.jmx -l test.jtl.

• Utilisez le moins d'auditeurs possible; si vous utilisez l'indicateur -l comme ci-dessus, ils peuvent tous être supprimés ou désactivés.

• Désactivez l'écouteur «Afficher l'arborescence des résultats» car il consomme beaucoup de mémoire et peut entraîner le gel de la console ou le manque de mémoire de JMeter. Il est cependant prudent d'utiliser l'écouteur «Afficher l'arborescence des résultats» avec uniquement «Erreurs» coché.

• Plutôt que d'utiliser de nombreux échantillonneurs similaires, utilisez le même échantillonneur dans une boucle et utilisez des variables (ensemble de données CSV) pour faire varier l'échantillon. Ou peut-être utiliser l'échantillonneur de journal d'accès.

• N'utilisez pas le mode fonctionnel.

• Utilisez la sortie CSV plutôt que XML.

• Enregistrez uniquement les données dont vous avez besoin.

• Utilisez le moins d'assertions possible.

• Désactivez tous les graphiques JMeter car ils consomment beaucoup de mémoire. Vous pouvez afficher tous les graphiques en temps réel à l'aide de l'onglet JTL de votre interface Web.

• N'oubliez pas d'effacer le chemin local de CSV Data Set Config s'il est utilisé.

• Nettoyez l'onglet Fichiers avant chaque exécution de test.