jMeter - Guida rapida

Prima di entrare nei dettagli di JMeter, dobbiamo prima comprendere alcuni gerghi associati al test di qualsiasi applicazione.

  • Performance Test- Questo test stabilisce le migliori aspettative di prestazioni possibili in una data configurazione di infrastruttura. Evidenzia inoltre nelle prime fasi del processo di test se è necessario apportare modifiche prima che l'applicazione entri in produzione.

  • Load Test - Questo test è fondamentalmente utilizzato per testare il sistema sotto il carico superiore per cui è stato progettato per funzionare.

  • Stress Test - Questo test è un tentativo di rompere il sistema sovraccaricando le sue risorse.

Cos'è JMeter?

JMeter è un software in grado di eseguire test di carico, test (funzionali) aziendali orientati alle prestazioni, test di regressione, ecc., Su diversi protocolli o tecnologie.

Stefano Mazzocchidella Apache Software Foundation è stato lo sviluppatore originale di JMeter. Lo scrisse principalmente per testare le prestazioni di Apache JServ (ora chiamato progetto Apache Tomcat). Apache ha successivamente riprogettato JMeter per migliorare la GUI e aggiungere funzionalità di test funzionale.

JMeter è un'applicazione desktop Java con un'interfaccia grafica che utilizza l'API grafica Swing. Può quindi funzionare su qualsiasi ambiente / workstation che accetti una macchina virtuale Java, ad esempio: Windows, Linux, Mac, ecc.

I protocolli supportati da JMeter sono:

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

  • Servizi Web - SOAP / XML-RPC

  • Database tramite driver JDBC

  • Directory - LDAP

  • Servizio orientato alla messaggistica tramite JMS

  • Servizio: POP3, IMAP, SMTP

  • Servizio FTP

Caratteristiche di JMeter

Di seguito sono riportate alcune delle caratteristiche di JMeter:

  • Essendo un software open source, è disponibile gratuitamente.

  • Ha una GUI semplice e intuitiva.

  • JMeter può condurre test di carico e prestazioni per molti tipi di server diversi: Web - HTTP, HTTPS, SOAP, Database tramite JDBC, LDAP, JMS, Mail - POP3, ecc.

  • È uno strumento indipendente dalla piattaforma. Su Linux / Unix, JMeter può essere richiamato facendo clic sullo script della shell JMeter. Su Windows, può essere richiamato avviando il file jmeter.bat.

  • Ha supporto Swing completo e componenti leggeri (il JAR precompilato utilizza i pacchetti javax.swing. *).

  • JMeter memorizza i suoi piani di test in formato XML. Ciò significa che puoi generare un piano di test utilizzando un editor di testo.

  • Il suo framework multi-threading completo consente il campionamento simultaneo di molti thread e il campionamento simultaneo di diverse funzioni da parte di gruppi di thread separati.

  • È altamente estensibile.

  • Può anche essere utilizzato per eseguire test automatici e funzionali delle applicazioni.

Come funziona JMeter?

JMeter simula un gruppo di utenti che inviano richieste a un server di destinazione e restituisce statistiche che mostrano le prestazioni / funzionalità del server / applicazione di destinazione tramite tabelle, grafici, ecc.

Dai un'occhiata alla figura seguente che mostra come funziona JMeter:

JMeter è un framework per Java, quindi il primo requisito è avere JDK installato sulla tua macchina.

Requisito del sistema

JDK 1.6 o superiore.
Memoria Nessun requisito minimo.
Spazio sul disco Nessun requisito minimo.
Sistema operativo Nessun requisito minimo.

Passaggio 1: verifica l'installazione di Java

Prima di tutto, verifica se sul tuo sistema è installato Java. Apri la tua console ed esegui una delle seguenti operazionijava comandi basati sul sistema operativo su cui stai lavorando.

OS Compito Comando
finestre Apri la Console di comando c: \> java -version
Linux Apri Terminale di comando $ java -version
Mac Apri Terminale macchina: ~ joseph $ java -version

Se hai Java installato nel tuo sistema, otterrai un output appropriato in base al sistema operativo su cui stai lavorando.

OS Produzione
finestre

versione java "1.7.0_25"

Java (TM) SE Runtime Environment (build 1.7.0_25-b15)

VM server Java HotSpot (TM) a 64 bit (build 23.25-b01, modalità mista)

Linux

versione java "1.7.0_25"

Java (TM) SE Runtime Environment (build 1.7.0_25-b15)

VM server Java HotSpot (TM) a 64 bit (build 23.25-b01, modalità mista)

Mac

versione java "1.7.0_25"

Java (TM) SE Runtime Environment (build 1.7.0_25-b15)

VM server Java HotSpot (TM) a 64 bit (build 23.25-b01, modalità mista)

Se non hai Java installato, installa il Java Software Development Kit (SDK) da www.oracle.com/technetwork/java/javase/downloads/index.html . Stiamo assumendo Java 1.7.0_25 come versione installata per questo tutorial.

Passaggio 2: impostare l'ambiente Java

Impostare il JAVA_HOMEvariabile d'ambiente in modo che punti alla posizione della directory di base, dove Java è installato sulla macchina. Ad esempio:

OS Produzione
finestre Imposta la variabile d'ambiente JAVA_HOME su C: \ Program Files \ Java \ jdk1.7.0_25
Linux export JAVA_HOME = / usr / local / java-current
Mac export JAVA_HOME = / Library / Java / Home

Aggiungi la posizione del compilatore Java al percorso di sistema.

OS Produzione
finestre Aggiungi la stringa; C: \ Program Files \ Java \ jdk1.7.0_25 \ bin alla fine della variabile di sistema, Path.
Linux export PATH = $ PATH: $ JAVA_HOME / bin /
Mac non richiesto

Verifica l'installazione di Java utilizzando java -version comando come spiegato sopra.

Passaggio 3: scarica JMeter

Scarica l'ultima versione di JMeter da https://jmeter.apache.org/download_jmeter.cgi. Per questo tutorial, abbiamo scaricato apache-jmeter-2.9 e lo abbiamo copiato nella cartella C: \> JMeter.

La struttura della directory dovrebbe apparire come quella mostrata di seguito -

  • 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

È possibile rinominare la directory principale (ad esempio apache-jmeter-2.9) se lo si desidera, ma non modificare nessuno dei nomi delle sottodirectory.

Passaggio 4: eseguire JMeter

Dopo aver scaricato JMeter, vai alla directory bin . In questo caso, lo è/home/manisha/apache-jmeter-2.9/bin. Ora fai clic su quanto segue:

OS Produzione
finestre jmeter.bat
Linux jmeter.sh
Mac jmeter.sh

Dopo una breve pausa, dovrebbe apparire la GUI di JMeter, che è un'applicazione Swing, come si vede nello screenshot seguente:

Questa è la pagina principale e la pagina predefinita dello strumento.

Cos'è un piano di test?

Un piano di test può essere visualizzato come un contenitore per l'esecuzione di test. Definisce cosa testare e come procedere. Un piano di test completo è costituito da uno o più elementi come gruppi di thread, controller logici, controller di generazione di campioni, listener, timer, asserzioni ed elementi di configurazione. Un piano di test deve avere almeno un gruppo di thread.

Scrivere un piano di test

Segui i passaggi indicati di seguito per scrivere un piano di test:

Passaggio 1: avviare la finestra di JMeter

Aprire la finestra di JMeter facendo clic su /home/manisha/apache-jmeter-2.9/bin/jmeter.sh. La finestra di JMeter apparirà come di seguito:

Questa è una finestra JMeter semplice e vuota senza l'aggiunta di elementi aggiuntivi. Contiene due nodi:

  • Test Plan node - è dove viene conservato il vero piano di test.

  • Workbench node- Fornisce semplicemente un luogo in cui memorizzare temporaneamente gli elementi del test quando non sono in uso, a scopo di copia / incolla. Quando si salva il piano di test, gli elementi di Workbench non vengono salvati con esso.

Passaggio 2: aggiungi / rimuovi elementi

Gli elementi (che saranno discussi nel prossimo capitolo Elementi del piano di test ) possono essere aggiunti a un piano di test facendo clic con il pulsante destro del mouse sul nodo Piano di test e scegliendo un nuovo elemento dall'elenco "aggiungi".

In alternativa, puoi caricare un elemento da un file e aggiungerlo scegliendo l'opzione "unisci" o "apri".

Ad esempio, aggiungiamo un elemento Gruppo thread a un piano di test come mostrato di seguito:

Per rimuovere un elemento, assicurati che l'elemento sia selezionato, fai clic con il pulsante destro del mouse sull'elemento e scegli l'opzione "rimuovi".

Passaggio 3: caricare e salvare gli elementi

Per caricare un elemento dal file -

  • Fare clic con il pulsante destro del mouse sull'elemento della struttura esistente a cui si desidera aggiungere l'elemento caricato.
  • Seleziona Unisci.
  • Scegli il file in cui hai salvato gli elementi.
  • JMeter unirà gli elementi nell'albero.

Per impostazione predefinita, JMeter non salva l'elemento, è necessario salvarlo esplicitamente.

Per salvare gli elementi dell'albero -

  • Fare clic con il tasto destro sull'elemento.
  • Scegli l' opzione Salva selezione con nome ...

JMeter salverà l'elemento selezionato, più tutti gli elementi figlio sottostanti. Per impostazione predefinita, JMeter non salva gli elementi, è necessario salvarlo esplicitamente come accennato in precedenza.

Passaggio 4: configurazione degli elementi dell'albero

Qualsiasi elemento nel piano di test può essere configurato utilizzando i controlli presenti nel frame di destra di JMeter. Questi controlli consentono di configurare il comportamento di quel particolare elemento di test. Ad esempio, il gruppo di thread può essere configurato per un numero di utenti, periodi di avvio, ecc., Come mostrato di seguito:

Passaggio 5: salvataggio del piano di test

È possibile salvare un intero piano di test utilizzando entrambi Save o "Save Test Plan As ..." dal menu File.

Passaggio 6: eseguire il piano di test

È possibile eseguire il piano di test facendo clic su Start(Control + r) da Runelemento del menu. Quando JMeter inizia a funzionare, mostra una piccola casella verde all'estremità destra della sezione appena sotto la barra dei menu.

I numeri a sinistra della casella verde sono il numero di thread attivi / numero totale di thread. Questi si applicano solo a un test eseguito localmente; non includono alcun thread avviato su sistemi remoti quando si utilizza la modalità client-server.

Passaggio 7: interrompere il piano di test

Puoi interrompere il test in due modi:

  • Utilizzando Stop(Ctrl + "."). Se possibile, interrompe immediatamente i thread.

  • Utilizzando Shutdown(Ctrl + ","). Richiede che i thread si interrompano alla fine di qualsiasi lavoro in corso.

Un piano di test JMeter comprende gli elementi di test discussi di seguito. Un piano di test comprende almeno un gruppo di thread. All'interno di ogni gruppo di thread, possiamo inserire una combinazione di uno o più di altri elementi: campionatore, controller logico, elemento di configurazione, ascoltatore e timer. Ogni Sampler può essere preceduto da uno o più elementi Pre-processore, seguito da un elemento Post-processore e / o da un elemento Assertion. Vediamo in dettaglio ciascuno di questi elementi:

Gruppo thread

Gli elementi del gruppo thread sono i punti di inizio del piano di test. Come suggerisce il nome, gli elementi del gruppo thread controllano il numero di thread che JMeter utilizzerà durante il test. Possiamo anche controllare quanto segue tramite il gruppo thread:

  • Impostazione del numero di thread

  • Impostazione del tempo di accelerazione

  • Impostazione del numero di iterazioni di test

Il pannello di controllo del gruppo di thread ha questo aspetto:

Il pannello Thread Group contiene i seguenti componenti:

  • Action to be taken after a Sampler error - Nel caso in cui si verifichi un errore durante l'esecuzione del test, puoi lasciare che il test -

    • Continue all'elemento successivo del test

    • Stop Thread per interrompere il thread corrente.

    • Stop Test completamente, nel caso in cui si desideri esaminare l'errore prima che continui a funzionare.

  • Number of Threads - Simula il numero di utenti o connessioni all'applicazione server.

  • Ramp-Up Period Definisce quanto tempo impiegherà JMeter per far funzionare tutti i thread.

  • Loop Count - Definisce il numero di volte per eseguire il test.

  • Scheduler checkbox - Una volta selezionata, la sezione Configurazione pianificazione viene visualizzata nella parte inferiore del pannello di controllo.

  • Scheduler Configuration - È possibile configurare l'ora di inizio e di fine dell'esecuzione del test.

Controller

JMeter ha due tipi di controller: campionatori e controller logici .

Campionatori

I campionatori consentono a JMeter di inviare tipi specifici di richieste a un server. Simulano una richiesta utente per una pagina dal server di destinazione. Ad esempio, è possibile aggiungere un campionatore di richieste HTTP se è necessario eseguire un POST, GET o DELETE su un servizio HTTP.

Alcuni utili campionatori sono:

  • Richiesta HTTP
  • Richiesta FTP
  • Richiesta JDBC
  • Richiesta Java
  • Richiesta SOAP / XML
  • Richieste RPC

Lo screenshot seguente mostra un pannello di controllo del campionatore di richieste HTTP -

Controller logici

I controller logici consentono di controllare l'ordine di elaborazione dei campionatori in un thread. I controller logici possono modificare l'ordine di una richiesta proveniente da qualsiasi elemento figlio. Alcuni esempi sono: ForEach Controller, While Controller, Loop Controller, IF Controller, Run Time Controller, Interleave Controller, Throughput Controller e Run Once Controller.

La seguente schermata mostra un pannello di controllo del controller di loop:

Il seguente elenco è costituito da tutti i controller logici forniti da JMeter:

  • Controller semplice
  • Controller di loop
  • Once Only Controller
  • Controller interleave
  • Controller casuale
  • Controller ordine casuale
  • Throughput Controller
  • Controller di runtime
  • Se Controller
  • Mentre Controller
  • Switch Controller
  • ForEach Controller
  • Controller del modulo
  • Includi controller
  • Controller delle transazioni
  • Controller di registrazione

Frammenti di prova

Un frammento di prova è un tipo speciale di elemento posizionato allo stesso livello dell'elemento gruppo thread. Si distingue da un gruppo di thread in quanto non viene eseguito a meno che non venga referenziato da un controller del modulo o da un include_controller. Questo elemento serve esclusivamente per il riutilizzo del codice all'interno dei piani di test.

Ascoltatori

I listener ti consentono di visualizzare i risultati di Samplers sotto forma di tabelle, grafici, alberi o testo semplice in alcuni file di registro. Forniscono accesso visivo ai dati raccolti da JMeter sui casi di test mentre viene eseguito un componente Sampler di JMeter.

Gli ascoltatori possono essere aggiunti ovunque nel test, anche direttamente sotto il piano di test. Raccoglieranno dati solo da elementi al loro livello o al di sotto di esso. Il seguente elenco comprende tutti gli ascoltatori forniti da JMeter:

  • Configurazione di salvataggio dei risultati di esempio
  • Risultati completi del grafico
  • Risultati grafici
  • Visualizzatore spline
  • Risultati dell'asserzione
  • Visualizza albero dei risultati
  • Rapporto aggregato
  • Visualizza i risultati nella tabella
  • Semplice scrittore di dati
  • Monitorare i risultati
  • Grafico di distribuzione (alfa)
  • Grafico aggregato
  • Mailer Visualizer
  • BeanShell Listener
  • Relazione di sintesi

Timer

Per impostazione predefinita, un thread JMeter invia richieste senza interruzioni tra ogni campionatore. Questo potrebbe non essere quello che vuoi. È possibile aggiungere un elemento timer che consente di definire un periodo di attesa tra ogni richiesta.

Il seguente elenco mostra tutti i timer forniti da JMeter:

  • Timer costante
  • Timer casuale gaussiano
  • Timer casuale uniforme
  • Timer di produttività costante
  • Sincronizzazione del timer
  • JSR223 Time
  • BeanShell Time
  • Ora BSF
  • Poisson Random Time

Lo screenshot seguente mostra un pannello di controllo del timer costante:

Asserzioni

Le asserzioni consentono di includere alcuni test di convalida sulla risposta della richiesta effettuata utilizzando un campionatore. Utilizzando le asserzioni puoi dimostrare che la tua applicazione sta restituendo i dati corretti. JMeter evidenzia quando un'asserzione fallisce.

Il seguente elenco comprende tutte le affermazioni fornite da JMeter:

  • Beanshell Assertion
  • Asserzione BSF
  • Confronta asserzione
  • Asserzione JSR223
  • Asserzione di risposta
  • Asserzione di durata
  • Asserzione di dimensioni
  • Asserzione XML
  • Asserzione BeanShell
  • Asserzione MD5Hex
  • Asserzione HTML
  • Asserzione XPath
  • Asserzione dello schema XML

Lo screenshot seguente mostra un pannello di controllo dell'asserzione delle risposte:

Elementi di configurazione

Gli elementi di configurazione consentono di creare valori predefiniti e variabili da utilizzare con i campionatori. Sono usati per aggiungere o modificare le richieste fatte da Samplers.

Vengono eseguiti all'inizio dell'ambito di cui fanno parte, prima di qualsiasi Campionatore che si trova nello stesso ambito. Pertanto, un elemento di configurazione è accessibile solo dall'interno del ramo in cui è posizionato.

Il seguente elenco è costituito da tutti gli elementi di configurazione forniti da JMeter:

  • Counter
  • Config. Set di dati CSV
  • Default richiesta FTP
  • Gestore autorizzazioni HTTP
  • HTTP Cache Manager
  • HTTP Cookie Manager
  • Server proxy HTTP
  • Default richiesta HTTP
  • HTTP Header Manager
  • Default richiesta Java
  • Configurazione del keystore
  • Configurazione connessione JDBC
  • Elemento di configurazione dell'accesso
  • Impostazioni predefinite della richiesta LDAP
  • Impostazioni predefinite richieste estese LDAP
  • TCP Sampler Config
  • Variabili definite dall'utente
  • Semplice elemento di configurazione
  • Variabile casuale

Elementi pre-processore

Un elemento pre-processore è qualcosa che viene eseguito appena prima dell'esecuzione di un campionatore. Sono spesso utilizzati per modificare le impostazioni di una richiesta di esempio appena prima che venga eseguita o per aggiornare le variabili che non vengono estratte dal testo della risposta.

Il seguente elenco è composto da tutti gli elementi pre-processore forniti da JMeter:

  • Parser link HTML
  • Modificatore di riscrittura URL HTTP
  • Modificatore parametro utente HTTP
  • Parametri utente
  • PreProcessore JDBC
  • PreProcessor JSR223
  • Parametri utente RegEx
  • BeanShell PreProcessor
  • PreProcessore BSF

Elementi post-processore

Un post-processore viene eseguito dopo che un campionatore termina la sua esecuzione. Questo elemento viene spesso utilizzato per elaborare i dati di risposta, ad esempio, per recuperare un valore particolare per un uso successivo.

Il seguente elenco è costituito da tutti gli elementi post-processore forniti da JMeter:

  • Estrattore di espressioni regolari
  • XPath Extractor
  • Gestore azione stato risultato
  • PostProcessor JSR223
  • PostProcessor JDBC
  • PostProcessor BSF
  • CSS / JQuery Extractor
  • PostProcessor BeanShell
  • Debug PostProcessor

Ordine di esecuzione degli elementi di test

Di seguito è riportato l'ordine di esecuzione degli elementi del piano di test:

  • Elementi di configurazione
  • Pre-Processors
  • Timers
  • Sampler
  • Post-processori (a meno che SampleResult non sia nullo)
  • Asserzioni (a meno che SampleResult non sia null)
  • Listener (a meno che SampleResult non sia null)

Costruiamo un semplice piano di test che testa una pagina web. Scriviamo un piano di test in Apache JMeter in modo da poter testare le prestazioni della pagina web mostrata dall'URL - www.tutorialspoint.com .

Avvia JMeter

Apri la finestra di JMeter facendo clic su /home/manisha/apache-jmeter-2.9/bin/jmeter.sh. La finestra di JMeter appare come di seguito:

Rinomina il piano di test

Modificare il nome del nodo del piano di test in Test di esempio nella casella di testo Nome . È necessario modificare lo stato attivo sul nodo workbench e tornare al nodo Piano di test per vedere il nome riflesso.

Aggiungi gruppo thread

Ora aggiungiamo il nostro primo elemento nella finestra. Aggiungiamo un gruppo di thread, che è un segnaposto per tutti gli altri elementi come Samplers, Controller e Listeners. Ne abbiamo bisogno in modo da poter configurare il numero di utenti da simulare.

In JMeter, tutti gli elementi del nodo vengono aggiunti utilizzando il menu contestuale.

  • Fare clic con il pulsante destro del mouse sull'elemento in cui si desidera aggiungere un nodo dell'elemento figlio.

  • Scegli l'opzione appropriata da aggiungere.

  • Fare clic con il pulsante destro del mouse sul test di esempio (il nostro piano di test) → Aggiungi → Thread (utenti) → Gruppo thread. Pertanto, il gruppo di thread viene aggiunto nel nodo Piano di test (test di esempio).

  • Assegna un nome al gruppo di thread come utenti . Per noi, questo elemento significa che gli utenti visitano la Home Page di TutorialsPoint.

Aggiungi campionatore

Dobbiamo aggiungere un campionatore nel nostro gruppo thread (utenti). Come fatto in precedenza per l'aggiunta del gruppo Thread, questa volta apriremo il menu contestuale del nodo Thread Group (Users) facendo clic con il pulsante destro del mouse e aggiungeremo HTTP Request Sampler scegliendo Aggiungi → Sampler → opzione di richiesta HTTP.

Aggiungerà un campionatore di richieste HTTP vuoto nel nodo Thread Group (Users). Cerchiamo di configurare questo elemento nodo -

  • Name- Cambierà il nome per riflettere l'azione che vogliamo ottenere. Lo chiameremo comeVisit TutorialsPoint Home Page

  • Server Name or IP- Qui dobbiamo digitare il nome del server web. Nel nostro caso lo èwww.tutorialspoint.com. (http: // parte non è scritta, questo è solo il nome del server o il suo IP)

  • Protocol - Lo terremo vuoto, il che significa che vogliamo HTTP come protocollo.

  • Path- Digiteremo path come / (slash). Significa che vogliamo la pagina principale del server.

Aggiungi ascoltatore

Ora aggiungeremo un ascoltatore. Aggiungiamo il listener della struttura ad albero dei risultati di visualizzazione nel nodo Thread Group (User). Garantirà che i risultati del Sampler saranno disponibili per la visualizzazione in questo elemento del nodo Listener.

Per aggiungere un ascoltatore:

  • Apri il menu contestuale

  • Fare clic con il pulsante destro del mouse sul gruppo di thread (utenti)

  • Scegli l'opzione Aggiungi → Listener → Visualizza albero dei risultati

Esegui il piano di test

Ora con tutte le impostazioni, eseguiamo il piano di test. Con la configurazione del gruppo di thread (utenti), manteniamo tutti i valori predefiniti. Significa che JMeter eseguirà il campionatore solo una volta. È simile a un singolo utente, solo una volta.

È simile a un utente che visita una pagina Web tramite browser, con JMeter sampler. Per eseguire il piano di test, selezionare Esegui dal menu e selezionare l'opzione Avvia.

Apache JMeter ci chiede di salvare il piano di test in un file su disco prima di iniziare effettivamente il test. Questo è importante se desideri eseguire il piano di test più volte. Puoi optare per eseguirlo senza salvare troppo.

Visualizza l'output

Abbiamo mantenuto l'impostazione del gruppo di thread come thread singolo (un solo utente) e loop per 1 volta (eseguito solo una volta), quindi otterremo il risultato di una singola transazione nel Listener View Result Tree.

I dettagli del risultato di cui sopra sono:

  • Il colore verde accanto al nome Visita la home page di TutorialsPoint indica il successo.

  • JMeter ha memorizzato tutte le intestazioni e le risposte inviate dal server web ed è pronto a mostrarci il risultato in molti modi.

  • La prima scheda è Sampler Results. Mostra i dati di JMeter così come i dati restituiti dal server web.

  • La seconda scheda è Richiesta, che mostra tutti i dati inviati al server web come parte della richiesta.

L'ultima scheda è Dati di risposta. In questa scheda, il listener mostra i dati ricevuti dal server in formato testo.

Questo è solo un semplice piano di test che esegue una sola richiesta. Ma il vero punto di forza di JMeter sta nell'inviare la stessa richiesta, come se molti utenti la stessero inviando. Per testare i server Web con più utenti, è necessario modificare le impostazioni del gruppo di thread (utenti).

In questo capitolo vedremo come creare un semplice piano di test per testare il server database. Per il nostro scopo di test utilizziamo il server di database MYSQL. È possibile utilizzare qualsiasi altro database per il test. Per l'installazione e la creazione di tabelle in MYSQL, fare riferimento al Tutorial MYSQL .

Una volta installato MYSQL, segui i passaggi seguenti per configurare il database:

  • Crea un database con il nome "tutorial".

  • Crea una tabella tutorials_tbl .

  • Inserisci i record in tutorials_tbl come mostrato di seguito -

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>
  • Copiare il driver JDBC appropriato in /home/manisha/apache-jmeter-2.9/lib.

Crea piano di test JMeter

Cominciamo JMeter da /home/manisha/apache-jmeter-2.9/bin/jmeter.sh.

Aggiungi utenti

Per creare un gruppo di thread,

  • Fare clic con il pulsante destro del mouse su Piano di test.

  • Seleziona Aggiungi → Thread (utenti) → Gruppo thread.

  • Pertanto, il gruppo di thread viene aggiunto nel nodo Piano di test.

  • Rinomina questo gruppo di thread come utenti JDBC .

Non cambieremo le proprietà predefinite del gruppo di thread.

Aggiunta di richieste JDBC

Ora che abbiamo definito i nostri utenti, è il momento di definire le attività che eseguiranno. In questa sezione, specificare le richieste JDBC da eseguire.

  • Fare clic con il pulsante destro del mouse sull'elemento Utenti JDBC.

  • Selezionare Add → Config Element → JDBC Connection Configuration.

  • Imposta i seguenti campi (stiamo usando il database MySQL chiamato tutorial) -

    • Nome variabile associato al pool. Ciò deve identificare la configurazione in modo univoco. Viene utilizzato da JDBC Sampler per identificare la configurazione da utilizzare. L'abbiamo chiamato come test .

    • URL del database - jdbc: mysql: // localhost: 3306 / tutorial.

    • Classe driver JDBC: com.mysql.jdbc.Driver.

    • Nome utente: root.

    • Password: password per root.

Gli altri campi sullo schermo vengono lasciati come predefiniti come mostrato di seguito -

Ora aggiungi una richiesta JDBC che fa riferimento al pool di configurazione JDBC definito sopra. Seleziona l'elemento Utenti JDBC.

  • Fare clic con il pulsante destro del mouse per visualizzare il menu Aggiungi

  • Selezionare Add → Sampler → JDBC Request.

  • Seleziona questo nuovo elemento per visualizzare il suo pannello di controllo.

  • Modifica le proprietà come mostrato di seguito:

    • Nome variabile associato al pool. Ciò deve identificare in modo univoco la configurazione. Viene utilizzato da JDBC Sampler per identificare la configurazione da utilizzare. L'ho chiamato test .

    • Nome - Impara.

    • Immettere il nome del pool - test (lo stesso dell'elemento di configurazione).

    • Tipo di query: selezionare l'istruzione.

    • Immettere il campo Stringa query SQL.

Crea ascoltatore

Ora aggiungi l'elemento Listener. Questo elemento è responsabile dell'archiviazione di tutti i risultati delle richieste JDBC in un file e della presentazione di un modello visivo dei dati.

  • Seleziona l'elemento Utenti JDBC

  • Aggiungi un listener della struttura ad albero dei risultati di visualizzazione (Add → Listener → View Results Tree).

Salva ed esegui il piano di test

Ora salva il piano di test sopra come db_test.jmx . Esegui questo piano di test utilizzandoRun → Start opzione.

Verifica l'output

Nell'ultima immagine, puoi vedere che sono selezionati due record.

In questo capitolo vedremo come testare un sito FTP usando JMeter. Creiamo un piano di test per testare il sito FTP.

Rinomina piano di test

  • Apri la finestra JMeter facendo clic su /home/manisha/apache-jmeter-2.9/bin/jmeter.sh

  • Fare clic sul nodo Piano di test.

  • Rinomina questo nodo del piano di test come TestFTPSite.

Aggiungi gruppo thread

Aggiungi un gruppo thread, che è un segnaposto per tutti gli altri elementi come campionatori, controller e ascoltatori.

  • Fare clic con il tasto destro su TestFTPSite (il nostro piano di test)

  • Seleziona Aggiungi → Thread (utenti) → Gruppo thread. Il gruppo di thread verrà aggiunto sotto il nodo Test Plan (TestFTPSite).

  • Modificare le proprietà predefinite del gruppo di thread per adattarle ai nostri test come segue:

    • Name - Utenti FTP

    • Number of Threads (Users) - 4

    • Ramp-Up Period - lasciare il valore predefinito di 0 secondi.

    • Loop Count - 1

Aggiungi campionatore - Richiesta FTP

Ora che abbiamo definito i nostri utenti, è il momento di definire le attività che eseguiranno. Aggiungi elementi di richiesta FTP. Aggiungiamo due elementi di richiesta FTP, uno che recupera un file e l'altro che inserisce un file sul sito ftp.

  • Seleziona l'elemento FTP users.

  • Fare clic con il pulsante destro del mouse per visualizzare il menu Aggiungi

  • Seleziona Aggiungi → Campionatore → Richiesta FTP.

  • Selezionare l'elemento Richiesta FTP nella struttura ad albero.

  • Modifica le seguenti proprietà come mostrato di seguito:

In questo elemento vengono inseriti i seguenti dettagli:

  • Name - Ottieni richiesta FTP

  • Server Name or IP - 184.168.74.29

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

  • Local File - sample_ftp.txt

  • Seleziona ottieni (RETR)

  • Username - manisha

  • Password - manisha123

Ora aggiungi un'altra richiesta FTP come sopra e modifica le proprietà come mostrato nello screenshot seguente -

In questo elemento vengono inseriti i seguenti dettagli:

  • Name - Inserimento richiesta FTP

  • Server Name or IP - 184.168.74.29

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

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

  • Seleziona inserisci (STOR)

  • Username - manisha

  • Password - manisha123

Aggiungi ascoltatore

L'ultimo elemento che devi aggiungere al tuo piano di test è un ascoltatore. Questo elemento è responsabile della memorizzazione di tutti i risultati delle tue richieste FTP in un file e della presentazione di un modello visivo dei dati.

  • Seleziona l'elemento FTP users.

  • Aggiungere un listener Visualizza albero dei risultati selezionando Aggiungi> Listener> Visualizza albero dei risultati.

Esegui il piano di test

Ora salva il piano di test sopra come ftpsite_test.jmx . Esegui questo piano di test utilizzandoRun → Start opzione.

Visualizza l'output

Il seguente output può essere visto nel listener.

Puoi vedere che vengono effettuate quattro richieste per ciascuna richiesta FTP e il test ha esito positivo. Il file recuperato per la richiesta GET viene archiviato nella cartella / bin. Nel nostro caso lo è/home/manisha/apache-jmeter-2.9/bin/. Per la richiesta PUT, il file viene caricato nel percorso/home/manisha/.

In questo capitolo impareremo come creare un piano di test per testare un WebService. Ai fini del nostro test, abbiamo creato un semplice progetto di servizio web e lo abbiamo implementato sul server Tomcat in locale.

Crea progetto di servizio Web

Per creare un progetto di servizio web, abbiamo utilizzato Eclipse IDE. Scrivere prima l'interfaccia dell'endpoint del servizioHelloWorld sotto il pacchetto com.tutorialspoint.ws. I contenuti di HelloWorld.java sono i seguenti:

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);
}

Questo servizio ha un metodo getHelloWorldMessage che accetta un parametro String.

Successivamente, crea la classe di implementazione HelloWorldImpl.java sotto il pacchetto 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");
   }
}

Pubblichiamo ora questo servizio Web in locale creando l'Endpoint publisher ed esponiamo il servizio sul server.

Il metodo di pubblicazione richiede due parametri:

  • Stringa URL endpoint.

  • Oggetto implementatore, in questo caso la classe di implementazione HelloWorld, che viene esposta come servizio Web nell'endpoint identificato dall'URL menzionato nel parametro precedente.

I contenuti di HelloWorldPublisher.java sono i seguenti:

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());
   }
}

Modifica il contenuto di web.xml come mostrato di seguito -

<?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>

Per distribuire questa applicazione come servizio web, avremmo bisogno di un altro file di configurazione sun-jaxws.xml. I contenuti di questo file sono i seguenti:

<?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>

Ora che tutti i file sono pronti, la struttura della directory apparirà come mostrato nello screenshot seguente:

  • Ora crea un file WAR di questa applicazione.

  • Scegli il progetto → fai clic con il pulsante destro del mouse → Esporta → File WAR.

  • Salva come hello.war file sotto il webapps cartella del server Tomcat.

  • Ora avvia il server Tomcat.

  • Una volta avviato il server, dovresti essere in grado di accedere al servizio web con l'URL - http: // localhost: 8080 / hello / hello

Crea un piano di test JMeter

Ora creiamo un piano di test per testare il servizio web di cui sopra.

Rinomina il piano di test

  • Apri la finestra JMeter facendo clic su /home/manisha/apache-jmeter2.9/bin/jmeter.sh.

  • Fare clic sul nodo Piano di test.

  • Rinomina questo nodo del piano di test come WebserviceTest.

Aggiungi gruppo thread

Aggiungi un gruppo thread, che è un segnaposto per tutti gli altri elementi come campionatori, controller e ascoltatori.

  • Fare clic con il tasto destro su WebserviceTest (il nostro piano di test) → Aggiungi → Thread (utenti) → Gruppo thread. Il gruppo di thread verrà aggiunto nel nodo Piano di test (WebserviceTest).

  • Successivamente, modifichiamo le proprietà predefinite del gruppo di thread per adattarle ai nostri test. Le seguenti proprietà vengono modificate:

    • Name - utente del servizio web

    • Number of Threads (Users) - 2

    • Ramp-Up Period - lasciare il valore predefinito di 0 secondi.

    • Loop Count - 2

Aggiungi campionatore - Richiesta SOAP / XML-RPC

Ora che abbiamo definito gli utenti, è il momento di definire le attività che eseguiranno.

Aggiungeremo l'elemento richiesta SOAP / XML-RPC -

  • Fare clic con il pulsante destro del mouse per visualizzare il menu Aggiungi.

  • Selezionare Aggiungi → Campionatore → Richiesta SOAP / XML-RPC.

  • Selezionare l'elemento SOAP / XML-RPC Request nella struttura ad albero

  • Modifica le seguenti proprietà come nell'immagine qui sotto:

  • In questo elemento vengono inseriti i seguenti dettagli:

    • Name − SOAP/XML-RPC Request

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

    • Soap/XML-RPC Data - Immettere i contenuti seguenti

<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>

Aggiungi ascoltatore

L'ultimo elemento che devi aggiungere al tuo piano di test è un ascoltatore. Questo elemento è responsabile dell'archiviazione di tutti i risultati delle richieste HTTP in un file e della presentazione di un modello visivo dei dati.

  • Seleziona l'elemento utente del servizio web.

  • Aggiungere un listener Visualizza albero dei risultati selezionando Aggiungi → Listener → Visualizza albero dei risultati.

Esegui il piano di test

Ora salva il piano di test sopra come test_webservice.jmx . Esegui questo piano di test utilizzando l'opzione Esegui → Avvia.

Visualizza l'output

Il seguente output può essere visto nel listener.

Nell'ultima immagine, puoi vedere il messaggio di risposta "Hello Manisha to JAX WS world".

In questo capitolo impareremo come scrivere un semplice piano di test per testare Java Messaging Service (JMS). JMS supporta due tipi di messaggistica:

  • Point-to-Point messaging- La messaggistica in coda viene generalmente utilizzata per le transazioni in cui il mittente si aspetta una risposta. I sistemi di messaggistica sono molto diversi dalle normali richieste HTTP. In HTTP, un singolo utente invia una richiesta e ottiene una risposta.

  • Topic messaging- I messaggi di argomento sono comunemente noti come messaggi pub / sub. La messaggistica di argomenti viene generalmente utilizzata nei casi in cui un messaggio viene pubblicato da un produttore e utilizzato da più abbonati.

Vediamo un esempio di prova per ciascuno di questi. I prerequisiti per testare JMS sono:

  • Usiamo Apache ActiveMQ nell'esempio. Esistono vari server JMS come IBM WebSphere MQ (precedentemente MQSeries), Tibco, ecc. Scaricalo dai file binari dal sito Web di Apache ActiveMQ.

  • Decomprimere l'archivio, andare alla directory decompressa ed eseguire il seguente comando dalla console dei comandi per avviare il server ActiveMQ:

.\bin\activemq  start

È possibile verificare se il server ActiveMQ è stato avviato visitando l'interfaccia di amministrazione al seguente indirizzo http://localhost:8161/admin/. Se richiede l'autenticazione, inserisci l'ID utente e la password come amministratore . Lo schermo è simile a quello mostrato di seguito:

  • Ora copia activemq-all-xxxjar (XXX a seconda della versione) dalla directory decompressa di ActiveMQ a /home/manisha/apache-jmeter-2.9/lib.

Con la configurazione di cui sopra, costruiamo il piano di test per:

In questo capitolo, discuteremo come creare un piano di test utilizzando JMeter per monitorare i server web. Gli usi dei test del monitor sono i seguenti:

  • I monitor sono utili per uno stress test e per la gestione del sistema.

  • Utilizzato con le prove di stress, il monitor fornisce informazioni aggiuntive sulle prestazioni del server.

  • I monitor rendono più semplice vedere la relazione tra le prestazioni del server e il tempo di risposta sul lato client.

  • In quanto strumento di amministrazione del sistema, il monitor fornisce un modo semplice per monitorare più server da una console.

Abbiamo bisogno di Tomcat 5 o superiore per il monitoraggio. Ai fini del nostro test, monitoreremo il server Tomcat 7.0.42. È possibile testare qualsiasi contenitore servlet che supporti Java Management Extension (JMX). Scriviamo un test case per monitorare il server Tomcat. Per prima cosa configuriamo il nostro server Tomcat.

Imposta il server Tomcat

Iniziamo con l'apertura dello stato del servizio Tomcat. A tale scopo, modificare il file di configurazione per gli utenti,<TOMCAT_HOME>/conf/tomcat-users.xml. Questo file contiene una sezione Tomcat-users (commentata) come mostrato -

<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>

Dobbiamo cambiare questa sezione per aggiungere i ruoli di amministratore, manager, manager-gui e assegnare l'utente "admin". Il file revisionato è il seguente:

<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>

Ora avvia il server Tomcat <TOMCAT_HOME> /bin/startup.sh per Linux e <TOMCAT_HOME> /bin/startup.bat per Windows. Una volta avviato, verifica che la supervisione di Tomcat funzioni inserendo il seguente link nel tuo browser:

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

Viene visualizzata una finestra di autenticazione nel browser. Inserisci il login e la password di Tomcat associati (nel nostro caso è admin). Quindi, il browser mostra lo stato di esecuzione di Tomcat come di seguito:

Dallo screenshot sopra, possiamo notare alcune cose:

  • Nell'URL, notare che XML = true (notare la distinzione tra maiuscole e minuscole) consente una visualizzazione pulita del Tomcat di supervisione necessario per il funzionamento di JMeter.

  • Notare inoltre che ci sono due connettori predefiniti. Il connettore AJP usato in generale accoppiato con il modulo frontale Mod_jk Apache HTTPD e il connettore HTTP che è comunemente usato connettore per l'accesso diretto a Tomcat tramite la porta 8080.

Scrivi JMeter Test Plan

Cerchiamo di monitorare il server Tomcat scrivendo un piano di test -

Rinomina piano di test

  • Apri la finestra JMeter facendo clic su /home/manisha/apache-jmeter2.9/bin/jmeter.sh.

  • Fare clic sul nodo Piano di test.

  • Aggiungi un gruppo di thread come spiegato nel passaggio successivo.

Aggiungi gruppo thread

  • Fare clic con il tasto destro su Test Plan → Add → Threads(Users) → Thread Group. Il gruppo di thread verrà aggiunto nel nodo Piano di test.

  • Modificare il conteggio dei loop su per sempre (o su un numero elevato) in modo da generare un numero sufficiente di campioni.

Gestore autorizzazioni HTTP

  • Aggiungi Gestore autorizzazioni HTTP all'elemento Gruppo thread selezionando Aggiungi → Elemento di configurazione → Gestore autorizzazioni HTTP. Questo elemento gestisce l'autenticazione richiesta dal browser per vedere lo stato del server Tomcat.

  • Seleziona il gestore delle autorizzazioni HTTP.

  • Modifica i seguenti dettagli:

    • Username - admin (a seconda della configurazione nel file tomcat-users.xml)

    • Password - admin (a seconda della configurazione nel file tomcatusers.xml)

    • Gli altri campi vengono lasciati vuoti.

Aggiungi richiesta Sampler-HTTP

Ora che abbiamo definito i nostri utenti, è il momento di definire le attività che eseguiranno. Aggiungiamo l'elemento di richiesta HTTP.

  • Fare clic con il pulsante destro del mouse per ottenere il menu Aggiungi.

  • Seleziona Aggiungi → Campionatore → Richiesta HTTP.

  • Quindi selezionare l'elemento Richiesta HTTP nella struttura ad albero.

  • Modifica le seguenti proprietà come nell'immagine qui sotto:

  • In questo elemento vengono inseriti i seguenti dettagli:

    • Name - Stato del server

    • Server Name or IP - localhost

    • Port - 8080

    • Path - / manager / status

    • Parameters- Aggiungere un parametro di richiesta denominato "XML" in maiuscolo. Dagli un valore "vero" in minuscolo.

    • Optional Tasks - Selezionare "Use as Monitor" nella parte inferiore del campionatore.

Aggiungi un timer costante

Per richiedere periodicamente lo stato del server, aggiungere un Constant Timer che consentirà un intervallo di tempo tra ogni richiesta. Aggiungi un timer a questo gruppo di thread selezionando Aggiungi → Timer → Timer costante.

Immettere 5000 millisecondi nella casella Thread Delay . In generale, l'utilizzo di intervalli inferiori a 5 secondi può aggiungere stress al server. Scopri qual è un intervallo accettabile prima di distribuire il monitor nel tuo ambiente di produzione.

Aggiungi ascoltatore

L'ultimo elemento che devi aggiungere al tuo piano di test è un ascoltatore. Aggiungiamo due tipi di ascoltatori. Uno che memorizza i risultati in un file e il secondo che mostra la visualizzazione grafica dei risultati.

  • Seleziona l'elemento del gruppo di fili.

  • Aggiungi un listener di Simple Data Writer Aggiungi → Listener → Simple Data Writer.

  • Specifica una directory e un nome file del file di output (nel nostro caso, è /home/manisha/work/sample.csv)

  • Aggiungiamo un altro listener selezionando l'elemento del piano di test Aggiungi → Listener → Monitor risultati.

Esegui il piano di test

Ora salva il piano di test sopra come monitor_test.jmx . Esegui questo piano di test utilizzando l'opzione Esegui → Avvia.

Visualizza l'output

I risultati verranno salvati nel file /home/manisha/work/sample.csv. Puoi anche vedere un risultato grafico nel listener dei risultati del monitor come nell'immagine qui sotto.

Nota che il grafico ha didascalie su entrambi i lati del grafico. A sinistra c'è la percentuale e la destra è morta / sana. Se la linea della memoria si alza e si abbassa rapidamente, potrebbe indicare un thrash della memoria. In queste situazioni, è una buona idea creare il profilo dell'applicazione con Borland OptimizeIt o JProbe. Quello che vuoi vedere è un modello regolare per carico, memoria e thread. Qualsiasi comportamento irregolare di solito indica prestazioni scadenti o un bug di qualche tipo.

I listener forniscono l'accesso alle informazioni che JMeter raccoglie sui casi di test durante l'esecuzione di JMeter. I risultati o le informazioni raccolte dagli ascoltatori possono essere mostrati sotto forma di:

  • tree
  • tables
  • graphs
  • file di registro

Tutti i listener scrivono gli stessi dati grezzi nel file di output quando ne viene specificato uno.

Configurazione predefinita

Gli elementi predefiniti da salvare possono essere definiti in uno dei due modi seguenti:

  • Nel jmeter.properties(o user.properties) file. Questo file è presente in/bin cartella di JMeter. Per modificare il formato predefinito, trova la seguente riga in jmeter.properties -

jmeter.save.saveservice.output_format=
  • Utilizzando il popup di configurazione come mostrato nella seguente schermata:

JMeter crea i risultati di un test eseguito come JMeter Text Logs (JTL). Questi sono normalmente chiamati file JTL, poiché è l'estensione predefinita, ma è possibile utilizzare qualsiasi estensione.

Se vengono eseguiti più test utilizzando lo stesso nome del file di output, JMeter aggiunge automaticamente i nuovi dati alla fine del file.

L'ascoltatore può registrare i risultati in un file ma non nell'interfaccia utente. Ha lo scopo di fornire un mezzo efficiente per registrare i dati eliminando il sovraccarico della GUI.

Durante la corsa -

  • GUI mode - usa l'ascoltatore Simple Data Writer

  • non-GUI mode - il flag -l può essere utilizzato per creare un file di dati.

Gli ascoltatori possono utilizzare molta memoria se sono presenti molti campioni. Per ridurre al minimo la quantità di memoria necessaria, utilizzare il formato Simple Data Write con il formato CSV.

Formato registro CSV

Il formato del registro CSV dipende dagli elementi di dati selezionati nella configurazione. Solo gli elementi di dati specificati vengono registrati nel file. L'ordine di visualizzazione delle colonne è fisso ed è il seguente:

Campo Descrizione Esempio di valore
timeStamp in millisecondi dall'1 / 1/1970 1354223881017
trascorso in millisecondi 1858
etichetta etichetta del campionatore Richiesta HTTP
Codice di risposta ad esempio 200, 404 200
responseMessage ad es. OK ok
threadName Gruppo thread 1-1
tipo di dati ad es. testo testo
successo vero o falso vero
failureMessage se ce ne sono
byte numero di byte nel campione 34908
grpThreads numero di thread attivi in ​​questo gruppo di thread 1
allThreads numero totale di thread attivi in ​​tutti i gruppi 1
URL http://tutorialspoint.com
Nome del file se è stato utilizzato Salva risposta su file
latenza tempo per la prima risposta 132
codifica utf-8
SampleCount numero di campioni (1, a meno che non vengano aggregati più campioni) 1
ErrorCount numero di errori (0 o 1, a meno che non vengano aggregati più campioni) 0
Nome host dove è stato generato il campione LaptopManisha
Tempo di inattività numero di millisecondi di tempo 'Idle' (normalmente 0)
Variabili se specificato

Salvataggio dei dati di risposta

I dati di risposta possono essere salvati nel file di registro XML, se necessario. Tuttavia non consente di salvare file e immagini di grandi dimensioni. In questi casi, utilizzare Post-Processor Save_Responses_to_a_file. Questo genera un nuovo file per ogni campione e salva il nome del file con il campione. Il nome del file può quindi essere incluso nell'output del registro di esempio. I dati verranno recuperati dal file, se necessario, quando il file di registro di esempio viene ricaricato.

Caricamento (lettura) dei dati di risposta

Per visualizzare un file dei risultati esistente, è possibile utilizzare il pulsante "Sfoglia ..." per selezionare un file. Se necessario, crea semplicemente un testplan fittizio con il Listener appropriato al suo interno.

Salvataggio dei dati della GUI del listener

JMeter è in grado di salvare qualsiasi ascoltatore come file PNG. Fare così,

  • Seleziona l'ascoltatore nel pannello di sinistra selezionando Modifica → Salva come immagine. Viene visualizzata una finestra di dialogo file.

  • Immettere il nome desiderato.

  • Salva l'ascoltatore.

Funzioni JMeter e variabili utente

Le funzioni JMeter sono valori speciali che possono popolare i campi di qualsiasi Sampler o altro elemento in un albero di prova.

  • Una chiamata di funzione ha questo aspetto:

${__functionName(var1,var2,var3)}
  • _functionName corrisponde al nome di una funzione. Per esempio${__threadNum}.

  • Se un parametro di funzione contiene una virgola, assicurati di eseguire l'escape con "\" come mostrato di seguito -

${__time(EEE\, d MMM yyyy)}
  • Le variabili sono referenziate come -

${VARIABLE}

Elenco delle funzioni

La tabella seguente elenca un gruppo di funzioni vagamente raggruppate in tipi:

Tipo di funzione Nome Commento
Informazione threadNum Ottieni il numero del thread.
Informazione samplerName Ottieni il nome del campionatore (etichetta).
Informazione machineIP Ottieni l'indirizzo IP della macchina locale.
Informazione nome della macchina Ottieni il nome della macchina locale.
Informazione tempo Restituisce l'ora corrente in vari formati.
Informazione log Registra (o visualizza) un messaggio (e restituisci il valore).
Informazione logn Registra (o visualizza) un messaggio (valore restituito vuoto).
Ingresso StringFromFile Legge una riga da un file.
Ingresso FileToString Leggi un intero file.
Ingresso CSVRead Leggi da file delimitato CSV.
Ingresso XPath Usa un'espressione XPath per leggere da un file.
Calcolo contatore Genera un numero crescente.
Calcolo intSum Aggiungi numeri int.
Calcolo longSum Aggiungi numeri lunghi.
Calcolo Casuale Genera un numero casuale.
Calcolo RandomString Genera una stringa casuale.
Calcolo UUID Genera un UUID di tipo 4 casuale.
Scripting BeanShell Esegui uno script BeanShell.
Scripting javaScript Elabora JavaScript (Mozilla Rhino).
Scripting jexl, jexl2 Valuta un'espressione Commons Jexl.
Proprietà proprietà Leggere una proprietà.
Proprietà P Leggere una proprietà (metodo abbreviato).
Proprietà setProperty Imposta una proprietà JMeter.
Variabili Diviso Suddividi una stringa in variabili.
Variabili V Valuta il nome di una variabile.
Variabili eval Valuta un'espressione variabile.
Variabili evalVar Valuta un'espressione archiviata in una variabile.
Corda regexFunction Analizza la risposta precedente utilizzando un'espressione regolare.
Corda escapeOroRegexpChars Cita i meta caratteri usati dall'espressione regolare ORO.
Corda char Genera valori di caratteri Unicode da un elenco di numeri.
Corda unescape Elabora le stringhe contenenti gli escape Java (ad esempio \ n & \ t).
Corda unescapeHtml Decodifica le stringhe con codifica HTML.
Corda escapeHtml Codifica le stringhe utilizzando la codifica HTML.
Corda TestPlanName Restituisce il nome del piano di test corrente.
  • Esistono due tipi di funzioni:

    • Valori statici definiti dall'utente (o variabili)

    • Funzioni integrate

  • I valori statici definiti dall'utente consentono all'utente di definire le variabili da sostituire con il loro valore statico quando un albero di test viene compilato e inviato per essere eseguito.

  • Le variabili non possono essere annidate; cioè${Var${N}} non funziona.

  • La funzione __V (variabile) (versioni successive alla 2.2) può essere utilizzata per fare ciò - $ {__ V (Var $ {N})}.

  • Questo tipo di sostituzione è possibile senza funzioni, ma è meno conveniente e meno intuitivo.

Dove utilizzare funzioni e variabili

Le funzioni e le variabili possono essere scritte in qualsiasi campo di qualsiasi componente di test.

Le seguenti funzioni dovrebbero funzionare bene in un piano di test:

  • intSum
  • longSum
  • machineName
  • BeanShell
  • javaScript
  • jexl
  • random
  • time
  • funzioni di proprietà
  • funzioni di registro

Le funzioni utilizzate nel piano di test hanno alcune limitazioni. Le variabili di thread di JMeter non saranno state completamente impostate quando le funzioni vengono elaborate, quindi i nomi delle variabili passati come parametri non verranno impostati ei riferimenti alle variabili non funzioneranno. Quindi, split () e regex () e le funzioni di valutazione delle variabili non funzioneranno. La funzione threadNum () non funzionerà e non ha senso a livello di piano di test.

Riferimento a variabili e funzioni

  • Il riferimento a una variabile in un elemento di test viene eseguito racchiudendo il nome della variabile tra "$ {" e "}".

  • Si fa riferimento alle funzioni nello stesso modo, ma per convenzione i nomi delle funzioni iniziano con "__" per evitare conflitti con i nomi dei valori utente.

  • Alcune funzioni accettano argomenti per configurarle e vanno tra parentesi, delimitate da virgole. Se la funzione non accetta argomenti, le parentesi possono essere omesse. Ad esempio:

${__BeanShell(vars.put("name"\,"value"))}
  • In alternativa, puoi definire il tuo script come una variabile, ad esempio nel piano di test -

SCRIPT     vars.put("name","value")
  • Lo script può quindi essere referenziato come segue:

${__BeanShell(${SCRIPT})}

La finestra di dialogo dell'helper della funzione

La finestra di dialogo dell'helper di funzione è disponibile da JMeter Options tab.

  • Utilizzando l'helper di funzione, è possibile selezionare una funzione dal menu a discesa e assegnare valori per i suoi argomenti. La colonna di sinistra nella tabella fornisce una breve descrizione dell'argomento e la colonna di destra è dove scrivi il valore per quell'argomento. Diverse funzioni accettano argomenti diversi.

  • Dopo averlo fatto, fai clic sul pulsante "Genera" e viene generata la stringa appropriata, che puoi copiare e incollare nel piano di test ovunque sia necessario.

Variabili predefinite

Alcune variabili sono definite internamente da JMeter. Sono -

  • COOKIE_cookiename: contiene il valore del cookie.

  • JMeterThread.last_sample_ok - indipendentemente dal fatto che l'ultimo campione fosse OK o meno - vero / falso. Nota: viene aggiornato dopo l'esecuzione di PostProcessors e Assertions.

  • Variabili START.

Proprietà predefinite

Alcune proprietà integrate sono definite da JMeter. Questi sono elencati di seguito. Per comodità, le proprietà START vengono copiate anche nelle variabili con lo stesso nome.

  • START.MS: ora di inizio di JMeter in millisecondi.

  • START.YMD - Ora di inizio di JMeter come aaaaMMgg.

  • START.HMS - Ora di inizio di JMeter come HHmmss.

  • TESTSTART.MS: ora di inizio del test in millisecondi.

Notare che le variabili / proprietà START rappresentano l'ora di avvio di JMeter, non l'ora di inizio del test. Sono destinati principalmente all'uso nei nomi di file, ecc.

Le espressioni regolari vengono utilizzate per cercare e manipolare il testo, in base a modelli. JMeter interpreta forme di espressioni regolari o modelli utilizzati in un piano di test JMeter, includendo il software di corrispondenza dei modelli Apache Jakarta ORO .

Con l'uso di espressioni regolari, possiamo sicuramente risparmiare molto tempo e ottenere una maggiore flessibilità quando creiamo o miglioriamo un piano di test. Le espressioni regolari forniscono un metodo semplice per ottenere informazioni dalle pagine quando è impossibile o molto difficile prevedere un risultato.

Un esempio di utilizzo standard dell'utilizzo delle espressioni consiste nell'ottenere un ID di sessione dalla risposta del server. Se il server restituisce una chiave di sessione univoca, possiamo ottenerla facilmente utilizzando le espressioni nel nostro script di caricamento.

Per utilizzare espressioni regolari nel piano di test, è necessario utilizzare Regular Expression Extractor di JMeter. È possibile inserire espressioni regolari in qualsiasi componente di un piano di test.

Vale la pena sottolineare la differenza tra contains e matches, come utilizzato nell'elemento di test Asserzione risposta -

  • containssignifica che l'espressione regolare corrisponde almeno a una parte del target, quindi "alfabeto" "contiene" "ph.b." perché l'espressione regolare corrisponde alla sottostringa "phabe".

  • matchessignifica che l'espressione regolare corrisponde all'intero obiettivo. Quindi l '"alfabeto" è "abbinato" a "al. * T".

Supponi di voler abbinare la seguente porzione di una pagina web:

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

E vuoi estrarre readme.txt. Un'espressione regolare adatta sarebbe:

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

I caratteri speciali sopra sono:

  • ( e ) - questi racchiudono la parte della stringa di corrispondenza da restituire

  • . - corrisponde a qualsiasi carattere

  • + - una o più volte

  • ? - fermati quando la prima partita riesce

Crea piano di test JMeter

Comprendiamo l'uso delle espressioni regolari nell'estrattore di espressioni regolari, un elemento post-processore, scrivendo un piano di test. Questo elemento estrae il testo dalla pagina corrente utilizzando un'espressione regolare per identificare il modello di testo a cui è conforme un elemento desiderato.

Per prima cosa scriviamo una pagina HTML che contiene un elenco di persone e i loro ID email. Lo distribuiamo sul nostro server Tomcat. I contenuti di html (index.html) sono i seguenti:

<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>

Durante la distribuzione sul server Tomcat, questa pagina apparirà come mostrato nella seguente schermata:

Nel nostro piano di test, selezioneremo la persona nella prima riga della tabella delle persone visualizzata nella pagina dell'elenco delle persone sopra. Per acquisire l'ID di questa persona, determiniamo prima il modello in cui troveremo la persona nella seconda riga.

Come si può vedere nella seguente istantanea, l'ID della seconda persona è circondato da <td id = "ID"> e </ td>, ed è la seconda riga di dati con questo modello. Possiamo usarlo per abbinare il modello esatto da cui vogliamo estrarre le informazioni. Dato che vogliamo estrarre due informazioni da questa pagina, l'ID persona e il nome della persona, i campi sono definiti come segue:

Avvia JMeter, aggiungi un gruppo Thread Test Plan → Add→ Threads(Users)→ Thread Group.

Quindi aggiungi una richiesta HTTP del campionatore, seleziona il piano di test, fai clic con il pulsante destro del mouse Add → Sampler → HTTP Request e inserisci i dettagli come mostrato di seguito -

  • Name - Gestisci

  • Server Name or IP - localhost

  • Port Number - 8080

  • Protocol - Lo terremo vuoto, il che significa che vogliamo HTTP come protocollo.

  • Path - jmeter / index.html

Successivamente, aggiungi un Estrattore di espressioni regolari. Seleziona il campionatore richiesta HTTP (Gestisci), fai clic con il tasto destroAdd → Post Processor → Regular Expression Extractor.

La tabella seguente fornisce una descrizione dei campi utilizzati nella schermata sopra:

Suor n Campo e descrizione
1

Reference Name

Il nome della variabile in cui verrà memorizzato il test estratto (refname).

2

Regular Expression

Il modello rispetto al quale verrà confrontato il testo da estrarre. I gruppi di testo che verranno estratti sono racchiusi dai caratteri "(" e ")". Usiamo ". +?" per indicare una singola istanza del testo racchiuso dai tag <td ..> .. </td>. Nel nostro esempio l'espressione è - <td id = "ID"> (+?) </td> \ s * <td id = "Name"> (+?) </td> \ s *

3

Template

Ogni gruppo di testo estratto inserito come membro della variabile Persona, seguendo l'ordine di ogni gruppo di pattern racchiuso da '(' e ')'. Ogni gruppo viene memorizzato come refname_g #, dove refname è la stringa immessa come nome di riferimento e # è il numero del gruppo. $ 1 $ a si riferisce al gruppo 1, $ 2 $ a si riferisce al gruppo 2, ecc. $ 0 $ si riferisce a qualunque cosa corrisponda all'intera espressione. In questo esempio, l'ID che estraiamo è mantenuto in Person_g1, mentre il valore Name è memorizzato in Person_g2.

4

Match No.

Poiché abbiamo in programma di estrarre solo la seconda occorrenza di questo pattern, facendo corrispondere il secondo volontario, usiamo il valore 2. Il valore 0 farebbe una corrispondenza casuale, mentre un valore negativo deve essere utilizzato con il controller ForEach.

5

Default

Se l'elemento non viene trovato, questo sarà il valore predefinito. Questo è un campo facoltativo. Puoi lasciarlo vuoto.

Aggiungi un listener per acquisire il risultato di questo piano di test. Fare clic con il pulsante destro del mouse sul gruppo di thread e selezionare l'opzione Aggiungi → Listener → Visualizza albero dei risultati per aggiungere l'ascoltatore.

Salva il piano di test come reg_express_test.jmx ed esegui il test. L'output sarebbe un successo come mostrato nello screenshot seguente:

JMeter ha alcune limitazioni soprattutto quando viene eseguito in un ambiente distribuito. Seguire queste linee guida aiuterà a creare un carico reale e continuo:

  • Usa più istanze di JMeter nel caso in cui il numero di thread sia maggiore.

  • Controllare le regole di scoping e progettare di conseguenza.

  • Usa sempre le convenzioni di denominazione per tutti gli elementi.

  • Verificare le impostazioni di connettività del browser predefinito prima di eseguire gli script.

  • Aggiungi gli ascoltatori in modo appropriato.

  • Ecco alcuni suggerimenti per ridurre il fabbisogno di risorse:

    • Usa la modalità non GUI: jmeter -n -t test.jmx -l test.jtl.

    • Usa il minor numero di ascoltatori possibile; se si usa il flag -l come sopra, possono essere tutti cancellati o disabilitati.

    • Disabilitare il listener "Visualizza struttura ad albero dei risultati" poiché consuma molta memoria e può provocare il blocco della console o l'esaurimento della memoria di JMeter. Tuttavia, è sicuro utilizzare il listener "Visualizza albero dei risultati" con solo "Errori" selezionato.

    • Invece di utilizzare molti campionatori simili, utilizza lo stesso campionatore in un ciclo e utilizza le variabili (CSV Data Set) per variare il campione. O forse usa il campionatore registro di accesso.

    • Non utilizzare la modalità funzionale.

    • Utilizza l'output CSV anziché XML.

    • Salva solo i dati di cui hai bisogno.

    • Usa il minor numero di asserzioni possibile.

    • Disabilita tutti i grafici di JMeter poiché consumano molta memoria. Puoi visualizzare tutti i grafici in tempo reale utilizzando la scheda JTL nella tua interfaccia web.

    • Non dimenticare di cancellare il percorso locale da CSV Data Set Config, se utilizzato.

    • Pulisci la scheda File prima di ogni esecuzione di test.