jMeter - Guía rápida

Antes de entrar en los detalles de JMeter, primero comprendamos algunas jergas asociadas con las pruebas de cualquier aplicación.

  • Performance Test- Esta prueba establece la mejor expectativa de rendimiento posible bajo una determinada configuración de infraestructura. También destaca al principio del proceso de prueba si es necesario realizar algún cambio antes de que la aplicación entre en producción.

  • Load Test - Esta prueba se utiliza básicamente para probar el sistema bajo la carga superior para la que fue diseñado.

  • Stress Test - Esta prueba es un intento de romper el sistema sobrepasando sus recursos.

¿Qué es JMeter?

JMeter es un software que puede realizar pruebas de carga, pruebas (funcionales) comerciales orientadas al rendimiento, pruebas de regresión, etc., en diferentes protocolos o tecnologías.

Stefano Mazzocchide Apache Software Foundation fue el desarrollador original de JMeter. Lo escribió principalmente para probar el rendimiento de Apache JServ (ahora llamado proyecto Apache Tomcat). Posteriormente, Apache rediseñó JMeter para mejorar la GUI y agregar capacidades de prueba funcional.

JMeter es una aplicación de escritorio Java con una interfaz gráfica que utiliza la API gráfica Swing. Por lo tanto, puede ejecutarse en cualquier entorno / estación de trabajo que acepte una máquina virtual Java, por ejemplo: Windows, Linux, Mac, etc.

Los protocolos admitidos por JMeter son:

  • Web: sitios HTTP, HTTPS 'web 1.0' web 2.0 (ajax, flex y flex-ws-amf)

  • Servicios web - SOAP / XML-RPC

  • Base de datos a través de controladores JDBC

  • Directorio - LDAP

  • Servicio orientado a mensajería a través de JMS

  • Servicio: POP3, IMAP, SMTP

  • Servicio FTP

Funciones de JMeter

A continuación se presentan algunas de las características de JMeter:

  • Al ser un software de código abierto, está disponible gratuitamente.

  • Tiene una GUI simple e intuitiva.

  • JMeter puede realizar pruebas de carga y rendimiento para muchos tipos de servidores diferentes: Web - HTTP, HTTPS, SOAP, Base de datos a través de JDBC, LDAP, JMS, Correo - POP3, etc.

  • Es una herramienta independiente de la plataforma. En Linux / Unix, JMeter se puede invocar haciendo clic en el script de shell de JMeter. En Windows, se puede invocar iniciando el archivo jmeter.bat.

  • Tiene soporte completo para Swing y componentes ligeros (JAR precompilado usa paquetes javax.swing. *).

  • JMeter almacena sus planes de prueba en formato XML. Esto significa que puede generar un plan de prueba utilizando un editor de texto.

  • Su marco completo de subprocesos múltiples permite el muestreo simultáneo de muchos subprocesos y el muestreo simultáneo de diferentes funciones por grupos de subprocesos separados.

  • Es muy extensible.

  • También se puede utilizar para realizar pruebas funcionales y automatizadas de las aplicaciones.

¿Cómo funciona JMeter?

JMeter simula un grupo de usuarios que envían solicitudes a un servidor de destino y devuelve estadísticas que muestran el rendimiento / funcionalidad del servidor / aplicación de destino a través de tablas, gráficos, etc.

Eche un vistazo a la siguiente figura que muestra cómo funciona JMeter:

JMeter es un marco para Java, por lo que el primer requisito es tener JDK instalado en su máquina.

Requisitos del sistema

JDK 1.6 o superior.
Memoria Sin requisitos mínimos.
Espacio del disco Sin requisitos mínimos.
Sistema operativo Sin requisitos mínimos.

Paso 1: verificar la instalación de Java

Primero que nada, verifique si tiene Java instalado en su sistema. Abra su consola y ejecute uno de los siguientesjava comandos basados ​​en el sistema operativo en el que está trabajando.

SO Tarea Mando
Ventanas Abrir consola de comandos c: \> java -version
Linux Terminal de comando abierto $ java -version
Mac Terminal abierta máquina: ~ joseph $ java -version

Si tiene Java instalado en su sistema, obtendrá un resultado apropiado según el sistema operativo en el que está trabajando.

SO Salida
Ventanas

versión de Java "1.7.0_25"

Entorno de tiempo de ejecución de Java (TM) SE (compilación 1.7.0_25-b15)

Servidor VM Java HotSpot (TM) de 64 bits (compilación 23.25-b01, modo mixto)
Linux

versión de Java "1.7.0_25"

Entorno de tiempo de ejecución de Java (TM) SE (compilación 1.7.0_25-b15)

Servidor VM Java HotSpot (TM) de 64 bits (compilación 23.25-b01, modo mixto)
Mac

versión de Java "1.7.0_25"

Entorno de tiempo de ejecución de Java (TM) SE (compilación 1.7.0_25-b15)

Servidor VM Java HotSpot (TM) de 64 bits (compilación 23.25-b01, modo mixto)

Si no tiene Java instalado, instale Java Software Development Kit (SDK) desde www.oracle.com/technetwork/java/javase/downloads/index.html . Asumimos Java 1.7.0_25 como la versión instalada para este tutorial.

Paso 2: configurar el entorno Java

Selecciona el JAVA_HOMEvariable de entorno para apuntar a la ubicación del directorio base, donde Java está instalado en su máquina. Por ejemplo

SO Salida
Ventanas Establezca la variable de entorno JAVA_HOME en C: \ Archivos de programa \ Java \ jdk1.7.0_25
Linux exportar JAVA_HOME = / usr / local / java-current
Mac exportar JAVA_HOME = / Library / Java / Home

Agregue la ubicación del compilador de Java a la ruta del sistema.

SO Salida
Ventanas Agregue la cadena; C: \ Archivos de programa \ Java \ jdk1.7.0_25 \ bin hasta el final de la variable del sistema, Ruta.
Linux export PATH = $ PATH: $ JAVA_HOME / bin /
Mac no requerido

Verifique la instalación de Java usando java -version comando como se explicó anteriormente.

Paso 3: Descarga JMeter

Descargue la última versión de JMeter de https://jmeter.apache.org/download_jmeter.cgi. Para este tutorial, descargamos apache-jmeter-2.9 y lo copiamos en la carpeta C: \> JMeter.

La estructura del directorio debería verse como se muestra a continuación:

  • 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

Puede cambiar el nombre del directorio principal (es decir, apache-jmeter-2.9) si lo desea, pero no cambie ninguno de los nombres de los subdirectorios.

Paso 4: Ejecute JMeter

Después de descargar JMeter, vaya al directorio bin . En este caso lo es/home/manisha/apache-jmeter-2.9/bin. Ahora haga clic en lo siguiente:

SO Salida
Ventanas jmeter.bat
Linux jmeter.sh
Mac jmeter.sh

Después de una breve pausa, debería aparecer la GUI de JMeter, que es una aplicación Swing, como se ve en la siguiente captura de pantalla:

Esta es la página principal y la página predeterminada de la herramienta.

¿Qué es un plan de prueba?

Un plan de prueba puede verse como un contenedor para ejecutar pruebas. Define qué probar y cómo hacerlo. Un plan de prueba completo consta de uno o más elementos, como grupos de subprocesos, controladores lógicos, controladores de generación de muestras, oyentes, temporizadores, afirmaciones y elementos de configuración. Un plan de prueba debe tener al menos un grupo de subprocesos.

Escribir un plan de prueba

Siga los pasos que se indican a continuación para escribir un plan de prueba:

Paso 1: Inicie la ventana de JMeter

Abra la ventana de JMeter haciendo clic en /home/manisha/apache-jmeter-2.9/bin/jmeter.sh. La ventana de JMeter aparecerá como se muestra a continuación:

Esta es una ventana JMeter simple y en blanco sin ningún elemento adicional agregado. Contiene dos nodos:

  • Test Plan node - es donde se guarda el plan de prueba real.

  • Workbench node- Simplemente proporciona un lugar para almacenar temporalmente elementos de prueba mientras no están en uso, con fines de copiar / pegar. Cuando guarda su plan de prueba, los elementos de Workbench no se guardan con él.

Paso 2: agregar o quitar elementos

Los elementos (que se discutirán en el próximo capítulo Elementos del plan de prueba ) se pueden agregar a un plan de prueba haciendo clic con el botón derecho en el nodo Plan de prueba y eligiendo un nuevo elemento de la lista "agregar".

Alternativamente, puede cargar un elemento de un archivo y agregarlo eligiendo la opción "fusionar" o "abrir".

Por ejemplo, agreguemos un elemento de grupo de subprocesos a un plan de prueba como se muestra a continuación:

Para eliminar un elemento, asegúrese de que esté seleccionado, haga clic con el botón derecho en el elemento y elija la opción "eliminar".

Paso 3: Cargue y guarde los elementos

Para cargar un elemento desde un archivo:

  • Haga clic con el botón derecho en el elemento de árbol existente al que desea agregar el elemento cargado.
  • Seleccione Fusionar.
  • Elija el archivo donde guardó los elementos.
  • JMeter fusionará los elementos en el árbol.

De forma predeterminada, JMeter no guarda el elemento, debe guardarlo explícitamente.

Para guardar elementos del árbol:

  • Haz clic derecho en el elemento.
  • Elija la opción Guardar selección como ...

JMeter guardará el elemento seleccionado, más todos los elementos secundarios debajo de él. De forma predeterminada, JMeter no guarda los elementos, debe guardarlos explícitamente como se mencionó anteriormente.

Paso 4: configurar los elementos del árbol

Cualquier elemento del plan de prueba se puede configurar utilizando los controles presentes en el marco del lado derecho de JMeter. Estos controles le permiten configurar el comportamiento de ese elemento de prueba en particular. Por ejemplo, el grupo de subprocesos se puede configurar para varios usuarios, períodos de aceleración, etc., como se muestra a continuación:

Paso 5: guardar el plan de prueba

Puede guardar un plan de prueba completo utilizando Save o "Save Test Plan As ..." en el menú Archivo.

Paso 6: Ejecute el plan de prueba

Puede ejecutar el plan de prueba haciendo clic en Start(Control + r) desde Runopción del menú. Cuando JMeter comienza a ejecutarse, muestra un pequeño cuadro verde en el extremo derecho de la sección, justo debajo de la barra de menú.

Los números a la izquierda del cuadro verde son el número de subprocesos activos / número total de subprocesos. Estos solo se aplican a una prueba ejecutada localmente; no incluyen ningún hilo iniciado en sistemas remotos cuando se utiliza el modo cliente-servidor.

Paso 7: detener el plan de prueba

Puede detener su prueba de dos maneras:

  • Utilizando Stop(Control + '.'). Detiene los hilos inmediatamente si es posible.

  • Utilizando Shutdown(Control + ','). Solicita que los hilos se detengan al final de cualquier trabajo actual.

Un plan de prueba de JMeter comprende los elementos de prueba que se analizan a continuación. Un plan de prueba consta de al menos un grupo de subprocesos. Dentro de cada grupo de subprocesos, podemos colocar una combinación de uno o más de otros elementos: muestreador, controlador lógico, elemento de configuración, escucha y temporizador. Cada muestreador puede estar precedido por uno o más elementos de preprocesador, seguidos por un elemento de postprocesador y / o un elemento de afirmación. Veamos cada uno de estos elementos en detalle:

Grupo de subprocesos

Los elementos de Thread Group son los puntos iniciales de su plan de prueba. Como sugiere el nombre, los elementos del grupo de subprocesos controlan el número de subprocesos que utilizará JMeter durante la prueba. También podemos controlar lo siguiente a través del Grupo de subprocesos:

  • Establecer el número de hilos

  • Configuración del tiempo de aceleración

  • Establecer el número de iteraciones de prueba

El panel de control del grupo de subprocesos se ve así:

El Panel de grupo de subprocesos contiene los siguientes componentes:

  • Action to be taken after a Sampler error - En caso de que ocurra algún error durante la ejecución de la prueba, puede dejar que la prueba -

    • Continue al siguiente elemento de la prueba

    • Stop Thread para detener el hilo actual.

    • Stop Test por completo, en caso de que desee inspeccionar el error antes de que continúe ejecutándose.

  • Number of Threads - Simula el número de usuarios o conexiones a su aplicación de servidor.

  • Ramp-Up Period Define cuánto tiempo tardará JMeter en ejecutar todos los subprocesos.

  • Loop Count - Define el número de veces que se ejecutará la prueba.

  • Scheduler checkbox - Una vez seleccionado, la sección Configuración del programador aparece en la parte inferior del panel de control.

  • Scheduler Configuration - Puede configurar la hora de inicio y finalización de la ejecución de la prueba.

Controladores

JMeter tiene dos tipos de controladores: muestreadores y controladores lógicos .

Muestreadores

Los muestreadores permiten que JMeter envíe tipos específicos de solicitudes a un servidor. Simulan la solicitud de un usuario de una página desde el servidor de destino. Por ejemplo, puede agregar una muestra de solicitud HTTP si necesita realizar una POST, GET o DELETE en un servicio HTTP.

Algunos muestreadores útiles son:

  • Solicitud HTTP
  • Solicitud FTP
  • Solicitud JDBC
  • Solicitud de Java
  • Solicitud SOAP / XML
  • Solicitudes de RPC

La siguiente captura de pantalla muestra un panel de control del muestreador de solicitudes HTTP:

Controladores lógicos

Los controladores lógicos le permiten controlar el orden de procesamiento de los muestreadores en un hilo. Los controladores lógicos pueden cambiar el orden de una solicitud proveniente de cualquiera de sus elementos secundarios. Algunos ejemplos son: para cada controlador, mientras que el controlador, el controlador de lazo, el controlador IF, el controlador de tiempo de ejecución, el controlador de intercalación, el controlador de rendimiento y el controlador de ejecución única.

La siguiente captura de pantalla muestra un panel de control del controlador de bucle:

La siguiente lista consta de todos los controladores lógicos que proporciona JMeter:

  • Controlador simple
  • Controlador de bucle
  • Una sola vez controlador
  • Controlador de entrelazado
  • Controlador aleatorio
  • Controlador de orden aleatorio
  • Controlador de rendimiento
  • Controlador de tiempo de ejecución
  • Si controlador
  • Mientras que el controlador
  • Controlador de interruptor
  • Para cada controlador
  • Controlador de módulo
  • Incluir controlador
  • Controlador de transacciones
  • Controlador de grabación

Fragmentos de prueba

Un fragmento de prueba es un tipo especial de elemento colocado al mismo nivel que el elemento Thread Group. Se distingue de un grupo de subprocesos en que no se ejecuta a menos que sea referenciado por un controlador de módulo o un controlador de inclusión. Este elemento es puramente para la reutilización de código dentro de los planes de prueba.

Oyentes

Los oyentes le permiten ver los resultados de los muestreadores en forma de tablas, gráficos, árboles o texto simple en algunos archivos de registro. Proporcionan acceso visual a los datos recopilados por JMeter sobre los casos de prueba a medida que se ejecuta un componente Sampler de JMeter.

Se pueden agregar oyentes en cualquier lugar de la prueba, incluso directamente debajo del plan de prueba. Recopilarán datos solo de elementos a su nivel o por debajo de él. La siguiente lista consta de todos los oyentes que proporciona JMeter:

  • Ejemplo de configuración de guardado de resultado
  • Graficar resultados completos
  • Resultados gráficos
  • Visualizador de splines
  • Resultados de la afirmación
  • Ver árbol de resultados
  • Informe agregado
  • Ver resultados en la tabla
  • Escritor de datos simple
  • Monitorear resultados
  • Gráfico de distribución (alfa)
  • Gráfico agregado
  • Visualizador de correo
  • Oyente BeanShell
  • Informe resumido

Temporizadores

De forma predeterminada, un hilo de JMeter envía solicitudes sin pausa entre cada muestreador. Puede que esto no sea lo que quieres. Puede agregar un elemento de temporizador que le permite definir un período de espera entre cada solicitud.

La siguiente lista muestra todos los temporizadores que proporciona JMeter:

  • Temporizador constante
  • Temporizador aleatorio gaussiano
  • Temporizador aleatorio uniforme
  • Temporizador de rendimiento constante
  • Temporizador de sincronización
  • JSR223 Hora
  • BeanShell Time
  • Hora BSF
  • Tiempo aleatorio de Poisson

La siguiente captura de pantalla muestra un panel de control de temporizador constante:

Afirmaciones

Las afirmaciones le permiten incluir alguna prueba de validación en la respuesta de su solicitud realizada mediante un muestreador. Mediante afirmaciones, puede probar que su aplicación devuelve los datos correctos. JMeter destaca cuando falla una afirmación.

La siguiente lista consta de todas las afirmaciones que proporciona JMeter:

  • Afirmación de cáscara de frijol
  • Afirmación BSF
  • Comparar afirmación
  • Afirmación JSR223
  • Afirmación de respuesta
  • Afirmación de duración
  • Aserción de tamaño
  • Afirmación XML
  • Aserción BeanShell
  • Aserción MD5Hex
  • Afirmación HTML
  • Afirmación XPath
  • Afirmación de esquema XML

La siguiente captura de pantalla muestra un panel de control de afirmación de respuesta:

Elementos de configuración

Los elementos de configuración le permiten crear valores predeterminados y variables para que los utilicen los muestreadores. Se utilizan para agregar o modificar solicitudes realizadas por Samplers.

Se ejecutan al inicio del ámbito del que forman parte, antes que cualquier Samplers que se encuentre en el mismo ámbito. Por lo tanto, a un Elemento de Configuración se accede solo desde el interior de la sucursal donde está ubicado.

La siguiente lista consta de todos los elementos de configuración que proporciona JMeter:

  • Counter
  • Configuración del conjunto de datos CSV
  • Valores predeterminados de solicitud de FTP
  • Administrador de autorización HTTP
  • Administrador de caché HTTP
  • Administrador de cookies HTTP
  • Servidor proxy HTTP
  • Valores predeterminados de solicitud HTTP
  • Administrador de encabezados HTTP
  • Valores predeterminados de solicitud de Java
  • Configuración del almacén de claves
  • Configuración de la conexión JDBC
  • Elemento de configuración de inicio de sesión
  • Valores predeterminados de solicitud LDAP
  • Valores predeterminados de solicitud extendida de LDAP
  • Configuración del muestreador de TCP
  • Variables definidas por el usuario
  • Elemento de configuración simple
  • Variable aleatoria

Elementos del preprocesador

Un elemento de preprocesador es algo que se ejecuta justo antes de que se ejecute un muestreador. A menudo se utilizan para modificar la configuración de una solicitud de muestra justo antes de que se ejecute, o para actualizar variables que no se extraen del texto de respuesta.

La siguiente lista consta de todos los elementos de preprocesador que proporciona JMeter:

  • Analizador de enlaces HTML
  • Modificador de reescritura de URL HTTP
  • Modificador de parámetros de usuario HTTP
  • Parámetros de usuario
  • Preprocesador JDBC
  • Preprocesador JSR223
  • Parámetros de usuario de RegEx
  • Preprocesador BeanShell
  • Preprocesador BSF

Elementos de posprocesador

Un postprocesador se ejecuta después de que un muestreador finaliza su ejecución. Este elemento se utiliza con mayor frecuencia para procesar los datos de respuesta, por ejemplo, para recuperar un valor particular para su uso posterior.

La siguiente lista consta de todos los elementos de postprocesador que proporciona JMeter:

  • Extractor de expresiones regulares
  • Extractor XPath
  • Controlador de acción de estado de resultado
  • Postprocesador JSR223
  • Postprocesador JDBC
  • Postprocesador BSF
  • Extractor de CSS / JQuery
  • Postprocesador BeanShell
  • Postprocesador de depuración

Orden de ejecución de los elementos de prueba

A continuación se muestra el orden de ejecución de los elementos del plan de prueba:

  • Elementos de configuración
  • Pre-Processors
  • Timers
  • Sampler
  • Postprocesadores (a menos que SampleResult sea nulo)
  • Assertions (a menos que SampleResult sea nulo)
  • Oyentes (a menos que SampleResult sea nulo)

Construyamos un plan de prueba simple que pruebe una página web. Escribimos un plan de prueba en Apache JMeter para que podamos probar el rendimiento de la página web que muestra la URL: .

Iniciar JMeter

Abra la ventana de JMeter haciendo clic en /home/manisha/apache-jmeter-2.9/bin/jmeter.sh. La ventana de JMeter aparece como se muestra a continuación:

Cambiar el nombre del plan de prueba

Cambie el nombre del nodo del plan de prueba a Prueba de muestra en el cuadro de texto Nombre . Debe cambiar el enfoque al nodo del banco de trabajo y volver al nodo del plan de prueba para ver cómo se refleja el nombre.

Agregar grupo de subprocesos

Ahora agregamos nuestro primer elemento en la ventana. Agregamos un grupo de subprocesos, que es un marcador de posición para todos los demás elementos como muestreadores, controladores y oyentes. Necesitamos uno para poder configurar el número de usuarios a simular.

En JMeter, todos los elementos de nodo se agregan usando el menú contextual.

  • Haga clic con el botón derecho en el elemento donde desea agregar un nodo de elemento secundario.

  • Elija la opción adecuada para agregar.

  • Haga clic con el botón derecho en Prueba de muestra (nuestro Plan de prueba) → Agregar → Subprocesos (usuarios) → Grupo de subprocesos. Por lo tanto, el grupo de subprocesos se agrega bajo el nodo Plan de prueba (prueba de muestra).

  • Nombre el grupo de subprocesos como Usuarios . Para nosotros, este elemento significa que los usuarios visitan la página de inicio de TutorialsPoint.

Agregar muestreador

Necesitamos agregar un Sampler en nuestro grupo de subprocesos (usuarios). Como se hizo anteriormente para agregar el grupo de subprocesos, esta vez abriremos el menú contextual del nodo del grupo de subprocesos (usuarios) haciendo clic con el botón derecho y agregaremos el muestreador de solicitud HTTP seleccionando Agregar → Muestrario → opción de solicitud HTTP.

Agregará una muestra de solicitud HTTP vacía en el nodo Grupo de subprocesos (usuarios). Configuremos este elemento de nodo -

  • Name- Cambiaremos el nombre para reflejar la acción que queremos lograr. Lo nombraremos comoVisit TutorialsPoint Home Page

  • Server Name or IP- Aquí, tenemos que escribir el nombre del servidor web. En nuestro caso eswww.tutorialspoint.com. (http: // parte no está escrita, este es solo el nombre del servidor o su IP)

  • Protocol - Mantendremos este espacio en blanco, lo que significa que queremos HTTP como protocolo.

  • Path- Escribiremos la ruta como / (barra). Significa que queremos la página raíz del servidor.

Agregar oyente

Ahora agregaremos un oyente. Agreguemos View Results Tree Listener bajo el nodo Thread Group (User). Asegurará que los resultados del Sampler estén disponibles para ver en este elemento de nodo Listener.

Para agregar un oyente:

  • Abrir el menú contextual

  • Haga clic con el botón derecho en el grupo de subprocesos (usuarios)

  • Elija Agregar → Oyente → Ver opción de árbol de resultados

Ejecutar el plan de prueba

Ahora con toda la configuración, ejecutemos el plan de prueba. Con la configuración del Thread Group (Usuarios), mantenemos todos los valores predeterminados. Significa que JMeter ejecutará el muestreador solo una vez. Es similar a un solo usuario, solo una vez.

Esto es similar a un usuario que visita una página web a través del navegador, con el muestreador de JMeter. Para ejecutar el plan de prueba, seleccione Ejecutar en el menú y seleccione la opción Iniciar.

Apache JMeter nos pide que guardemos el plan de prueba en un archivo de disco antes de comenzar la prueba. Esto es importante si desea ejecutar el plan de prueba varias veces. Puede optar por ejecutarlo sin guardar también.

Ver la salida

Hemos mantenido la configuración del grupo de subprocesos como un solo subproceso (un solo usuario) y un bucle durante 1 vez (ejecutar solo una vez), por lo tanto, obtendremos el resultado de una sola transacción en el oyente Ver árbol de resultados.

Los detalles del resultado anterior son:

  • El color verde contra el nombre Visite la página de inicio de TutorialsPoint indica éxito.

  • JMeter ha almacenado todos los encabezados y las respuestas enviadas por el servidor web y está listo para mostrarnos el resultado de muchas maneras.

  • La primera pestaña es Resultados de muestra. Muestra datos de JMeter, así como datos devueltos por el servidor web.

  • La segunda pestaña es Solicitud, que muestra todos los datos enviados al servidor web como parte de la solicitud.

La última pestaña es Datos de respuesta. En esta pestaña, el oyente muestra los datos recibidos del servidor en formato de texto.

Este es solo un plan de prueba simple que ejecuta solo una solicitud. Pero la verdadera fortaleza de JMeter está en enviar la misma solicitud, como si muchos usuarios la estuvieran enviando. Para probar los servidores web con varios usuarios, debemos cambiar la configuración del grupo de subprocesos (usuarios).

En este capítulo, veremos cómo crear un plan de prueba simple para probar el servidor de la base de datos. Para nuestro propósito de prueba usamos el servidor de base de datos MYSQL. Puede utilizar cualquier otra base de datos para realizar pruebas. Para la instalación y creación de tablas en MYSQL, consulte el Tutorial de MYSQL .

Una vez que MYSQL esté instalado, siga los pasos a continuación para configurar la base de datos:

  • Crea una base de datos con el nombre "tutorial".

  • Cree una tabla tutorials_tbl .

  • Inserte registros en tutorials_tbl como se muestra a continuación:

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>

  • Copie el controlador JDBC apropiado a /home/manisha/apache-jmeter-2.9/lib.

Crear plan de prueba de JMeter

Empecemos el JMeter desde /home/manisha/apache-jmeter-2.9/bin/jmeter.sh.

Agregar usuarios

Para crear un grupo de subprocesos,

  • Haga clic derecho en Plan de prueba.

  • Seleccione Agregar → Subprocesos (usuarios) → Grupo de subprocesos.

  • Por lo tanto, el grupo de subprocesos se agrega bajo el nodo Plan de prueba.

  • Cambie el nombre de este grupo de subprocesos como usuarios de JDBC .

No cambiaremos las propiedades predeterminadas del grupo de subprocesos.

Agregar solicitudes JDBC

Ahora que definimos a nuestros usuarios, es el momento de definir las tareas que realizarán. En esta sección, especifique las solicitudes JDBC a realizar.

  • Haga clic con el botón derecho en el elemento Usuarios de JDBC.

  • Seleccione Add → Config Element → JDBC Connection Configuration.

  • Configure los siguientes campos (estamos usando la base de datos MySQL llamada tutorial):

    • Nombre de variable vinculado a la agrupación. Esto debe identificar la configuración de forma única. Lo utiliza el JDBC Sampler para identificar la configuración que se utilizará. Lo hemos nombrado como prueba .

    • URL de la base de datos - jdbc: mysql: // localhost: 3306 / tutorial.

    • Clase de controlador JDBC: com.mysql.jdbc.Driver.

    • Nombre de usuario: root.

    • Contraseña: contraseña de root.

Los otros campos de la pantalla se dejan como predeterminados, como se muestra a continuación:

Ahora agregue una solicitud JDBC que se refiere al grupo de configuración JDBC definido anteriormente. Seleccione el elemento Usuarios de JDBC.

  • Haga clic con el botón derecho del mouse para obtener el menú Agregar

  • Seleccione Add → Sampler → JDBC Request.

  • Seleccione este nuevo elemento para ver su Panel de control.

  • Edite las propiedades como se muestra a continuación:

    • Nombre de variable vinculado a la agrupación. Esto necesita identificar de forma única la configuración. Lo utiliza el JDBC Sampler para identificar la configuración que se utilizará. Lo nombró como prueba .

    • Nombre: aprender.

    • Ingrese el nombre de la piscina - prueba (igual que en el elemento de configuración).

    • Tipo de consulta: instrucción de selección.

    • Ingrese el campo Cadena de consulta SQL.

Crear oyente

Ahora agregue el elemento Listener. Este elemento es responsable de almacenar todos los resultados de sus solicitudes JDBC en un archivo y presentar un modelo visual de los datos.

  • Seleccione el elemento Usuarios de JDBC

  • Agregar un oyente de árbol de resultados de vista (Add → Listener → View Results Tree).

Guardar y ejecutar el plan de prueba

Ahora guarde el plan de prueba anterior como db_test.jmx . Ejecute este plan de prueba usandoRun → Start opción.

Verificar la salida

En la última imagen, puede ver que se seleccionan dos registros.

En este capítulo, veremos cómo probar un sitio FTP usando JMeter. Creemos un plan de prueba para probar el sitio FTP.

Cambiar el nombre del plan de prueba

  • Abra la ventana de JMeter haciendo clic en /home/manisha/apache-jmeter-2.9/bin/jmeter.sh

  • Haga clic en el nodo Plan de prueba.

  • Cambie el nombre de este nodo del plan de prueba como TestFTPSite.

Agregar grupo de subprocesos

Agregue un grupo de subprocesos, que es un marcador de posición para todos los demás elementos como muestreadores, controladores y oyentes.

  • Haga clic derecho en TestFTPSite (nuestro plan de prueba)

  • Seleccione Agregar → Subprocesos (usuarios) → Grupo de subprocesos. El grupo de subprocesos se agregará en el nodo del plan de prueba (TestFTPSite).

  • Modifique las propiedades predeterminadas del grupo de subprocesos para que se adapten a nuestras pruebas de la siguiente manera:

    • Name - Usuarios de FTP

    • Number of Threads (Users) - 4

    • Ramp-Up Period - deje el valor predeterminado de 0 segundos.

    • Loop Count - 1

Agregar muestreador: solicitud de FTP

Ahora que hemos definido a nuestros usuarios, es el momento de definir las tareas que realizarán. Agregue elementos de solicitud de FTP. Agregamos dos elementos de solicitud FTP, uno que recupera un archivo y el otro que coloca un archivo en el sitio ftp.

  • Seleccione el elemento de usuarios de FTP.

  • Haga clic con el botón derecho del mouse para obtener el menú Agregar

  • Seleccione Agregar → Muestreador → Solicitud de FTP.

  • Seleccione el elemento Solicitud FTP en el árbol.

  • Edite las siguientes propiedades como se muestra a continuación:

Los siguientes detalles se ingresan en este elemento:

  • Name - Solicitud FTP Obtener

  • Server Name or IP - 184.168.74.29

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

  • Local File - sample_ftp.txt

  • Seleccione obtener (RETR)

  • Username - manisha

  • Password - manisha123

Ahora agregue otra solicitud FTP como arriba y edite las propiedades como se muestra en la siguiente captura de pantalla:

Los siguientes detalles se ingresan en este elemento:

  • Name - Envío de solicitud de FTP

  • Server Name or IP - 184.168.74.29

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

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

  • Seleccionar poner (ALMACENAR)

  • Username - manisha

  • Password - manisha123

Agregar oyente

El último elemento que debe agregar a su plan de prueba es un oyente. Este elemento es responsable de almacenar todos los resultados de sus solicitudes FTP en un archivo y presentar un modelo visual de los datos.

  • Seleccione el elemento de usuarios de FTP.

  • Agregue un oyente Ver árbol de resultados seleccionando Agregar> Oyente> Ver árbol de resultados.

Ejecutar el plan de prueba

Ahora guarde el plan de prueba anterior como ftpsite_test.jmx . Ejecute este plan de prueba usandoRun → Start opción.

Ver la salida

La siguiente salida se puede ver en el oyente.

Puede ver que se realizan cuatro solicitudes para cada solicitud de FTP y que la prueba se realiza correctamente. El archivo recuperado para la solicitud GET se almacena en la carpeta / bin. En nuestro caso, es/home/manisha/apache-jmeter-2.9/bin/. Para la solicitud PUT, el archivo se carga en la ruta/home/manisha/.

En este capítulo, aprenderemos cómo crear un plan de prueba para probar un servicio web. Para nuestro propósito de prueba, hemos creado un proyecto de servicio web simple y lo implementamos en el servidor Tomcat localmente.

Crear proyecto de servicio web

Para crear un proyecto de servicio web, hemos utilizado Eclipse IDE. Primero escriba la interfaz de punto final de servicioHelloWorld debajo del paquete com.tutorialspoint.ws. El contenido de HelloWorld.java es el siguiente:

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

Este servicio tiene un método getHelloWorldMessage que toma un parámetro String.

A continuación, cree la clase de implementación HelloWorldImpl.java debajo del paquete 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");
   }
}

Publiquemos ahora este servicio web localmente creando el editor de Endpoint y exponiendo el servicio en el servidor.

El método de publicación toma dos parámetros:

  • Cadena de URL de extremo.

  • Objeto implementador, en este caso la clase de implementación HelloWorld, que se expone como un servicio web en el punto final identificado por la URL mencionada en el parámetro anterior.

El contenido de HelloWorldPublisher.java es el siguiente:

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

Modifique el contenido de web.xml como se muestra a continuación:

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

Para implementar esta aplicación como un servicio web, necesitaríamos otro archivo de configuración sun-jaxws.xml. El contenido de este archivo es el siguiente:

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

Ahora que todos los archivos están listos, la estructura del directorio se vería como se muestra en la siguiente captura de pantalla:

  • Ahora cree un archivo WAR de esta aplicación.

  • Elija el proyecto → haga clic derecho → Exportar → Archivo WAR.

  • Guardar esto como hello.war archivo bajo el webapps carpeta del servidor Tomcat.

  • Ahora inicie el servidor Tomcat.

  • Una vez que se inicia el servidor, debería poder acceder al servicio web con la URL: http: // localhost: 8080 / hello / hello

Crear plan de prueba de JMeter

Ahora creemos un plan de prueba para probar el servicio web anterior.

Cambiar el nombre del plan de prueba

  • Abra la ventana de JMeter haciendo clic en /home/manisha/apache-jmeter2.9/bin/jmeter.sh.

  • Haga clic en el nodo Plan de prueba.

  • Cambie el nombre de este nodo del plan de prueba como WebserviceTest.

Agregar grupo de subprocesos

Agregue un grupo de subprocesos, que es un marcador de posición para todos los demás elementos como muestreadores, controladores y oyentes.

  • Haga clic con el botón derecho en WebserviceTest (nuestro plan de prueba) → Agregar → Subprocesos (usuarios) → Grupo de subprocesos. El grupo de subprocesos se agregará en el nodo Plan de prueba (WebserviceTest).

  • A continuación, modifiquemos las propiedades predeterminadas del Grupo de subprocesos para que se adapten a nuestras pruebas. Se cambian las siguientes propiedades:

    • Name - usuario del servicio web

    • Number of Threads (Users) - 2

    • Ramp-Up Period - deje el valor predeterminado de 0 segundos.

    • Loop Count - 2

Agregar muestreador: solicitud SOAP / XML-RPC

Ahora que hemos definido a los usuarios, es hora de definir las tareas que realizarán.

Agregaremos el elemento de solicitud SOAP / XML-RPC -

  • Haga clic con el botón derecho del mouse para obtener el menú Agregar.

  • Seleccione Agregar → Muestreador → Solicitud SOAP / XML-RPC.

  • Seleccione el elemento de solicitud SOAP / XML-RPC en el árbol

  • Edite las siguientes propiedades como en la imagen a continuación:

  • Los siguientes detalles se ingresan en este elemento:

    • Name − SOAP/XML-RPC Request

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

    • Soap/XML-RPC Data - Ingrese los siguientes contenidos

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

Agregar oyente

El último elemento que debe agregar a su plan de prueba es un oyente. Este elemento es responsable de almacenar todos los resultados de sus solicitudes HTTP en un archivo y presentar un modelo visual de los datos.

  • Seleccione el elemento de usuario del servicio web.

  • Agregue un oyente Ver árbol de resultados seleccionando Agregar → Oyente → Ver árbol de resultados.

Ejecutar el plan de prueba

Ahora guarde el plan de prueba anterior como test_webservice.jmx . Ejecute este plan de prueba usando la opción Ejecutar → Iniciar.

Ver la salida

La siguiente salida se puede ver en el oyente.

En la última imagen, puede ver el mensaje de respuesta "Hola, Manisha al mundo JAX WS".

En este capítulo, aprenderemos cómo escribir un plan de prueba simple para probar Java Messaging Service (JMS). JMS admite dos tipos de mensajería:

  • Point-to-Point messaging- La mensajería en cola se utiliza generalmente para transacciones en las que el remitente espera una respuesta. Los sistemas de mensajería son bastante diferentes de las solicitudes HTTP normales. En HTTP, un solo usuario envía una solicitud y obtiene una respuesta.

  • Topic messaging- Los mensajes temáticos se conocen comúnmente como mensajes pub / sub. La mensajería temática se utiliza generalmente en los casos en que un productor publica un mensaje y varios suscriptores lo consumen.

Veamos un ejemplo de prueba para cada uno de estos. Los requisitos previos para probar JMS son:

  • Usamos Apache ActiveMQ en el ejemplo. Hay varios servidores JMS como IBM WebSphere MQ (anteriormente MQSeries), Tibco, etc. Descárguelo de los archivos binarios del sitio web Apache ActiveMQ.

  • Descomprima el archivo, vaya al directorio descomprimido y ejecute el siguiente comando desde la consola de comandos para iniciar el servidor ActiveMQ:

.\bin\activemq  start

Puede verificar si el servidor ActiveMQ se ha iniciado visitando la interfaz de administración en la siguiente dirección http://localhost:8161/admin/. Si solicita autenticación, ingrese el ID de usuario y la contraseña como administrador . La pantalla es similar a la que se muestra a continuación:

  • Ahora copie el activemq-all-xxxjar (XXX según la versión) del directorio descomprimido de ActiveMQ a /home/manisha/apache-jmeter-2.9/lib.

Con la configuración anterior, creemos el plan de prueba para:

En este capítulo, discutiremos cómo crear un plan de prueba usando JMeter para monitorear servidores web. Los usos de las pruebas de monitor son los siguientes:

  • Los monitores son útiles para las pruebas de estrés y la gestión del sistema.

  • Utilizado con pruebas de estrés, el monitor proporciona información adicional sobre el rendimiento del servidor.

  • Los monitores facilitan la visualización de la relación entre el rendimiento del servidor y el tiempo de respuesta del lado del cliente.

  • Como herramienta de administración del sistema, el monitor proporciona una forma sencilla de supervisar varios servidores desde una consola.

Necesitamos Tomcat 5 o superior para monitorear. Para nuestro propósito de prueba, monitorearemos el servidor Tomcat 7.0.42. Puede probar cualquier contenedor de servlet que admita Java Management Extension (JMX). Escribamos un caso de prueba para monitorear el servidor Tomcat. Primero configuremos nuestro servidor Tomcat.

Configurar el servidor Tomcat

Comenzamos abriendo el estado del servicio Tomcat. Para hacer esto, edite el archivo de configuración para usuarios,<TOMCAT_HOME>/conf/tomcat-users.xml. Este archivo contiene una sección de usuarios de tomcat (comentada) como se muestra:

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

Necesitamos cambiar esta sección para agregar los roles de administrador, administrador, administrador-gui y asignar el usuario "admin". El archivo revisado es el siguiente:

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

Ahora inicie el servidor Tomcat <TOMCAT_HOME> /bin/startup.sh para Linux y <TOMCAT_HOME> /bin/startup.bat para Windows. Una vez iniciado, verifique que la supervisión de Tomcat funcione ingresando el siguiente enlace en su navegador:

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

Aparece una ventana de autenticación en el navegador. Introduzca el nombre de usuario y la contraseña de Tomcat asociados (en nuestro caso es admin). Luego, el navegador muestra el estado de ejecución de Tomcat como se muestra a continuación:

De la captura de pantalla anterior, podemos notar algunas cosas:

  • En la URL, tenga en cuenta que XML = true (tenga en cuenta la distinción entre mayúsculas y minúsculas) permite una visualización limpia del Tomcat supervisor necesario para el funcionamiento de JMeter.

  • También tenga en cuenta que hay dos conectores predeterminados. El conector AJP utilizado en general junto con el módulo frontal mod_jk Apache HTTPD y el conector HTTP que se utiliza comúnmente para el acceso directo a Tomcat a través del puerto 8080.

Escriba el plan de prueba de JMeter

Supervisemos el servidor Tomcat escribiendo un plan de prueba:

Cambiar el nombre del plan de prueba

  • Abra la ventana de JMeter haciendo clic en /home/manisha/apache-jmeter2.9/bin/jmeter.sh.

  • Haga clic en el nodo Plan de prueba.

  • Agregue un grupo de subprocesos como se explica en el siguiente paso.

Agregar grupo de subprocesos

  • Haga clic derecho en Test Plan → Add → Threads(Users) → Thread Group. El grupo de subprocesos se agregará en el nodo Plan de prueba.

  • Cambie el recuento de bucles a para siempre (o un número grande) para que se generen suficientes muestras.

Administrador de autorización HTTP

  • Agregue HTTP Authorization Manager al elemento Thread Group seleccionando Agregar → Elemento de configuración → HTTP Authorization Manager. Este elemento gestiona la autenticación solicitada por el navegador para ver el estado del servidor Tomcat.

  • Seleccione el Administrador de autorización HTTP.

  • Edite los siguientes detalles:

    • Username - admin (dependiendo de la configuración en el archivo tomcat-users.xml)

    • Password - admin (dependiendo de la configuración en el archivo tomcatusers.xml)

    • Los otros campos quedan vacíos.

Agregar solicitud Sampler-HTTP

Ahora que hemos definido a nuestros usuarios, es el momento de definir las tareas que realizarán. Agregamos el elemento Solicitud HTTP.

  • Haga clic derecho con el botón del mouse para obtener el menú Agregar.

  • Seleccione Agregar → Muestreador → Solicitud HTTP.

  • Luego, seleccione el elemento Solicitud HTTP en el árbol.

  • Edite las siguientes propiedades como en la imagen a continuación:

  • Los siguientes detalles se ingresan en este elemento:

    • Name - Estado del servidor

    • Server Name or IP - localhost

    • Port - 8080

    • Path - / gerente / estado

    • Parameters- Agregue un parámetro de solicitud llamado "XML" en mayúsculas. Dale un valor de "verdadero" en minúsculas.

    • Optional Tasks - Marque "Usar como monitor" en la parte inferior del muestreador.

Agregar un temporizador constante

Para solicitar el estado del servidor periódicamente, agregue un temporizador constante que permitirá un intervalo de tiempo entre cada solicitud. Agregue un temporizador a este grupo de hilos seleccionando Agregar → Temporizador → Temporizador constante.

Introduzca 5000 milisegundos en el cuadro Thread Delay . En general, usar intervalos de menos de 5 segundos puede agregar estrés a su servidor. Descubra cuál es un intervalo aceptable antes de implementar el monitor en su entorno de producción.

Agregar oyente

El último elemento que debe agregar a su plan de prueba es un oyente. Agregamos dos tipos de oyentes. Uno que almacena los resultados en un archivo y el segundo que muestra la vista gráfica de los resultados.

  • Seleccione el elemento del grupo de hilos.

  • Agregar un oyente de Escritor de datos simple Agregar → Oyente → Escritor de datos simple.

  • Especifique un directorio y el nombre de archivo del archivo de salida (en nuestro caso, es /home/manisha/work/sample.csv)

  • Agreguemos otro oyente seleccionando el elemento del plan de prueba Agregar → Oyente → Monitorear resultados.

Ejecutar el plan de prueba

Ahora guarde el plan de prueba anterior como monitor_test.jmx . Ejecute este plan de prueba usando la opción Ejecutar → Iniciar.

Ver la salida

Los resultados se guardarán en el archivo /home/manisha/work/sample.csv. También puede ver un resultado gráfico en el detector de resultados de Monitor como en la imagen a continuación.

Tenga en cuenta que el gráfico tiene leyendas en ambos lados del gráfico. A la izquierda está el porcentaje y la derecha está muerta / sana. Si la línea de la memoria sube y baja rápidamente, podría indicar una pérdida de memoria. En esas situaciones, es una buena idea perfilar la aplicación con Borland OptimizeIt o JProbe. Lo que desea ver es un patrón regular de carga, memoria e hilos. Cualquier comportamiento errático suele indicar un rendimiento deficiente o un error de algún tipo.

Los oyentes brindan acceso a la información que JMeter recopila sobre los casos de prueba mientras se ejecuta JMeter. Los resultados o la información recopilada por los oyentes se pueden mostrar en forma de:

  • tree
  • tables
  • graphs
  • archivo de registro

Todos los oyentes escriben los mismos datos sin procesar en el archivo de salida cuando se especifica uno.

Configuración predeterminada

Los elementos predeterminados que se guardarán se pueden definir de una de las dos formas siguientes:

  • En el jmeter.properties(o user.properties) archivo. Este archivo está presente en el/bin carpeta de JMeter. Para cambiar el formato predeterminado, busque la siguiente línea en jmeter.properties -

jmeter.save.saveservice.output_format=

  • Utilizando la ventana emergente Config como se muestra en la siguiente captura de pantalla:

JMeter crea los resultados de una ejecución de prueba como JMeter Text Logs (JTL). Normalmente se denominan archivos JTL, ya que es la extensión predeterminada, pero se puede utilizar cualquier extensión.

Si se ejecutan varias pruebas con el mismo nombre de archivo de salida, JMeter agrega automáticamente nuevos datos al final del archivo.

El oyente puede registrar los resultados en un archivo, pero no en la interfaz de usuario. Está destinado a proporcionar un medio eficiente para registrar datos al eliminar la sobrecarga de la GUI.

Al correr en -

  • GUI mode - use el oyente Simple Data Writer

  • non-GUI mode - la bandera -l se puede utilizar para crear un archivo de datos.

Los oyentes pueden usar mucha memoria si hay muchas muestras. Para minimizar la cantidad de memoria necesaria, utilice la escritura de datos simple con formato CSV.

Formato de registro CSV

El formato de registro CSV depende de los elementos de datos seleccionados en la configuración. Solo los elementos de datos especificados se registran en el archivo. El orden de aparición de las columnas es fijo y es el siguiente:

Campo Descripción Ejemplo de valor
timeStamp en milisegundos desde 1/1/1970 1354223881017
transcurrido en milisegundos 1858
etiqueta etiqueta de muestra Solicitud HTTP
código de respuesta por ejemplo, 200, 404 200
responseMessage por ejemplo, OK Okay
threadName Grupo de hilos 1-1
tipo de datos por ejemplo, texto texto
éxito verdadero o falso cierto
FailMessage Si alguna
bytes número de bytes en la muestra 34908
grpThreads número de hilos activos en este grupo de hilos 1
todos los temas número total de hilos activos en todos los grupos 1
URL http://tutorialspoint.com
Nombre del archivo si se utilizó Guardar respuesta en archivo
latencia tiempo para la primera respuesta 132
codificacion utf-8
SampleCount número de muestras (1, a menos que se agreguen varias muestras) 1
ErrorCount número de errores (0 o 1, a menos que se agreguen varias muestras) 0
Nombre de host donde se generó la muestra LaptopManisha
Tiempo de inactividad número de milisegundos de tiempo de inactividad (normalmente 0)
Variables si se especifica

Guardar datos de respuesta

Los datos de respuesta se pueden guardar en el archivo de registro XML si es necesario. Sin embargo, no permite guardar archivos e imágenes de gran tamaño. En tales casos, use el Post-Procesador Save_Responses_to_a_file. Esto genera un nuevo archivo para cada muestra y guarda el nombre del archivo con la muestra. El nombre del archivo se puede incluir en la salida del registro de muestra. Los datos se recuperarán del archivo si es necesario cuando se vuelva a cargar el archivo de registro de muestra.

Cargando (leyendo) datos de respuesta

Para ver un archivo de resultados existente, puede utilizar el botón "Examinar ..." del archivo para seleccionar un archivo. Si es necesario, simplemente cree un plan de prueba ficticio con el Oyente apropiado en él.

Guardar los datos de la GUI del oyente

JMeter es capaz de guardar cualquier oyente como archivo PNG. Para hacerlo

  • Seleccione el oyente en el panel izquierdo seleccionando Editar → Guardar como imagen. Aparece un cuadro de diálogo de archivo.

  • Ingrese el nombre deseado.

  • Salva al oyente.

Funciones de JMeter y variables de usuario

Las funciones de JMeter son valores especiales que pueden rellenar campos de cualquier Sampler u otro elemento en un árbol de prueba.

  • Una llamada de función se ve así:

${__functionName(var1,var2,var3)}

  • _functionName coincide con el nombre de una función. Por ejemplo${__threadNum}.

  • Si un parámetro de función contiene una coma, asegúrese de escapar de esto con "\" como se muestra a continuación:

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

  • Las variables se denominan -

${VARIABLE}

Lista de funciones

La siguiente tabla enumera un grupo de funciones agrupadas libremente en tipos:

Tipo de función Nombre Comentario
Información threadNum Obtenga el número de hilo.
Información samplerName Obtenga el nombre de la muestra (etiqueta).
Información máquinaIP Obtenga la dirección IP de la máquina local.
Información nombre de la máquina Obtenga el nombre de la máquina local.
Información hora Devuelve la hora actual en varios formatos.
Información Iniciar sesión Registra (o muestra) un mensaje (y devuelve el valor).
Información iniciar sesión Registrar (o mostrar) un mensaje (valor de retorno vacío).
Entrada StringFromFile Leer una línea de un archivo.
Entrada FileToString Leer un archivo completo.
Entrada CSVRead Leer de archivo delimitado por CSV.
Entrada XPath Utilice una expresión XPath para leer de un archivo.
Cálculo mostrador Genere un número creciente.
Cálculo intSum Suma números int.
Cálculo longSum Suma números largos.
Cálculo Aleatorio Genera un número aleatorio.
Cálculo RandomString Genera una cadena aleatoria.
Cálculo UUID Genere un UUID de tipo 4 aleatorio.
Scripting BeanShell Ejecute un script de BeanShell.
Scripting javaScript Procesar JavaScript (Mozilla Rhino).
Scripting jexl, jexl2 Evalúe una expresión de Commons Jexl.
Propiedades propiedad Leer una propiedad.
Propiedades PAGS Leer una propiedad (método abreviado).
Propiedades setProperty Establezca una propiedad de JMeter.
Variables división Divide una cadena en variables.
Variables V Evalúe el nombre de una variable.
Variables eval Evalúa una expresión variable.
Variables evalVar Evalúa una expresión almacenada en una variable.
Cuerda regexFunction Analice la respuesta anterior utilizando una expresión regular.
Cuerda escapeOroRegexpChars Citar metacaracteres utilizados por la expresión regular ORO.
Cuerda carbonizarse Genere valores de caracteres Unicode a partir de una lista de números.
Cuerda huir Procesar cadenas que contienen escapes de Java (por ejemplo, \ n & \ t).
Cuerda unescapeHtml Decodifica cadenas codificadas en HTML.
Cuerda escapeHtml Codifique cadenas mediante codificación HTML.
Cuerda TestPlanName Devuelve el nombre del plan de prueba actual.

  • Hay dos tipos de funciones:

    • Valores estáticos definidos por el usuario (o variables)

    • Funciones integradas

  • Los valores estáticos definidos por el usuario permiten al usuario definir variables que se reemplazarán con su valor estático cuando se compila un árbol de prueba y se envía para su ejecución.

  • Las variables no se pueden anidar; es decir${Var${N}} No funciona.

  • La función __V (variable) (versiones posteriores a 2.2) se puede usar para hacer esto - $ {__ V (Var $ {N})}.

  • Este tipo de reemplazo es posible sin funciones, pero es menos conveniente y menos intuitivo.

Dónde usar funciones y variables

Las funciones y variables se pueden escribir en cualquier campo de cualquier componente de prueba.

Las siguientes funciones deberían funcionar bien en un plan de prueba:

  • intSum
  • longSum
  • machineName
  • BeanShell
  • javaScript
  • jexl
  • random
  • time
  • funciones de propiedad
  • funciones de registro

Las funciones que se utilizan en el plan de prueba tienen algunas restricciones. Las variables de subproceso de JMeter no se habrán configurado completamente cuando se procesen las funciones, por lo que los nombres de variables pasados ​​como parámetros no se configurarán y las referencias de variables no funcionarán. Por lo tanto, split () y regex () y las funciones de evaluación de variables no funcionarán. La función threadNum () no funcionará y no tiene sentido a nivel de plan de prueba.

Referenciar variables y funciones

  • La referencia a una variable en un elemento de prueba se hace entre corchetes el nombre de la variable con '$ {' y '}'.

  • Las funciones se referencian de la misma manera, pero por convención, los nombres de las funciones comienzan con "__" para evitar conflictos con los nombres de los valores de usuario.

  • Algunas funciones toman argumentos para configurarlas, y estos van entre paréntesis, delimitados por comas. Si la función no tiene argumentos, se pueden omitir los paréntesis. Por ejemplo

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

  • Alternativamente, puede definir su script como una variable, por ejemplo, en el Plan de prueba -

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

  • A continuación, se puede hacer referencia al script de la siguiente manera:

${__BeanShell(${SCRIPT})}

El cuadro de diálogo Asistente de funciones

El cuadro de diálogo Function Helper está disponible en JMeter's Options lengüeta.

  • Con el Asistente de funciones, puede seleccionar una función del menú desplegable y asignar valores para sus argumentos. La columna de la izquierda de la tabla proporciona una breve descripción del argumento, y la columna de la derecha es donde escribe el valor de ese argumento. Las diferentes funciones toman diferentes argumentos.

  • Una vez que haya hecho esto, haga clic en el botón "Generar" y se generará la cadena adecuada, que puede copiar y pegar en el plan de prueba donde lo necesite.

Variables predefinidas

Algunas variables son definidas internamente por JMeter. Ellos son -

  • COOKIE_cookiename: contiene el valor de la cookie.

  • JMeterThread.last_sample_ok - si la última muestra fue correcta o no - verdadero / falso. Nota: esto se actualiza después de que se hayan ejecutado PostProcessors y Assertions.

  • START variables.

Propiedades predefinidas

Algunas propiedades integradas están definidas por JMeter. Estos se enumeran a continuación. Por conveniencia, las propiedades START también se copian en variables con los mismos nombres.

  • START.MS - Hora de inicio de JMeter en milisegundos.

  • START.YMD - Hora de inicio de JMeter como aaaaMMdd.

  • START.HMS - Hora de inicio de JMeter como HHmmss.

  • TESTSTART.MS: hora de inicio de la prueba en milisegundos.

Tenga en cuenta que las variables / propiedades de INICIO representan la hora de inicio de JMeter, no la hora de inicio de la prueba. Están pensados ​​principalmente para su uso en nombres de archivos, etc.

Las expresiones regulares se utilizan para buscar y manipular texto, basándose en patrones. JMeter interpreta formas de expresiones regulares o patrones que se utilizan en un plan de prueba de JMeter, al incluir el software de coincidencia de patrones Apache Jakarta ORO .

Con el uso de expresiones regulares, ciertamente podemos ahorrar mucho tiempo y lograr una mayor flexibilidad a medida que creamos o mejoramos un plan de prueba. Las expresiones regulares proporcionan un método simple para obtener información de las páginas cuando es imposible o muy difícil predecir un resultado.

Un ejemplo de uso estándar del uso de expresiones es obtener un ID de sesión de la respuesta del servidor. Si el servidor devuelve una clave de sesión única, podemos obtenerla fácilmente usando expresiones en nuestro script de carga.

Para usar expresiones regulares en su plan de prueba, debe usar el Extractor de expresiones regulares de JMeter. Puede colocar expresiones regulares en cualquier componente de un plan de prueba.

Cabe destacar la diferencia entre contains y matches, como se usa en el elemento de prueba Response Assertion -

  • containssignifica que la expresión regular coincide con al menos una parte del objetivo, por lo que 'alfabeto' "contiene" 'ph.b.' porque la expresión regular coincide con la subcadena 'phabe'.

  • matchessignifica que la expresión regular coincide con todo el destino. Por lo tanto, el 'alfabeto' se "empareja" con 'al. * T'.

Suponga que desea hacer coincidir la siguiente parte de una página web:

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

Y desea extraer readme.txt. Una expresión regular adecuada sería:

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

Los caracteres especiales anteriores son:

  • ( y ) - estos encierran la parte de la cadena de coincidencia que se devolverá

  • . - coincidir con cualquier personaje

  • + - una o más veces

  • ? - detenerse cuando el primer partido tenga éxito

Crear plan de prueba de JMeter

Comprendamos el uso de expresiones regulares en el extractor de expresiones regulares, un elemento de posprocesador, escribiendo un plan de prueba. Este elemento extrae texto de la página actual utilizando una expresión regular para identificar el patrón de texto con el que se ajusta un elemento deseado.

Primero escribimos una página HTML con una lista de personas y sus ID de correo electrónico. Lo implementamos en nuestro servidor Tomcat. El contenido de html (index.html) es el siguiente:

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

Al implementarlo en el servidor tomcat, esta página se vería como se muestra en la siguiente captura de pantalla:

En nuestro plan de prueba, seleccionaremos a la persona en la primera fila de la tabla de personas que se ve en la página de lista de personas anterior. Para capturar la identificación de esta persona, primero determinemos el patrón donde encontraremos a la persona en la segunda fila.

Como se puede ver en la siguiente instantánea, el ID de la segunda persona está rodeado por <td id = "ID"> y </ td>, y es la segunda fila de datos que tiene este patrón. Podemos usar esto para hacer coincidir el patrón exacto del que queremos extraer información. Como queremos extraer dos piezas de información de esta página, la identificación de la persona y el nombre de la persona, los campos se definen de la siguiente manera:

Inicie JMeter, agregue un grupo de subprocesos Test Plan → Add→ Threads(Users)→ Thread Group.

A continuación, agregue una solicitud HTTP de muestra, seleccione el plan de prueba, haga clic derecho Add → Sampler → HTTP Request e ingrese los detalles como se muestra a continuación -

  • Name - Gestionar

  • Server Name or IP - localhost

  • Port Number - 8080

  • Protocol - Mantendremos este espacio en blanco, lo que significa que queremos HTTP como protocolo.

  • Path - jmeter / index.html

A continuación, agregue un Extractor de expresiones regulares. Seleccione el muestreador de solicitud HTTP (administrar), haga clic derechoAdd → Post Processor → Regular Expression Extractor.

La siguiente tabla proporciona una descripción de los campos utilizados en la captura de pantalla anterior:

No Señor Campo Descripción
1

Reference Name

El nombre de la variable en la que se almacenará la prueba extraída (refname).
2

Regular Expression

El patrón con el que se comparará el texto que se extraerá. Los grupos de texto que se extraerán están delimitados por los caracteres '(' y ')'. Usamos '. +?' para indicar una única instancia del texto encerrado por las etiquetas <td ..> .. </td>. En nuestro ejemplo, la expresión es - <td id = "ID"> (+?) </td> \ s * <td id = "Name"> (+?) </td> \ s *
3

Template

Cada grupo de texto extraído se coloca como miembro de la variable Persona, siguiendo el orden de cada grupo de patrón encerrado por '(' y ')'. Cada grupo se almacena como refname_g #, donde refname es la cadena que ingresó como nombre de referencia y # es el número de grupo. $ 1 $ a se refiere al grupo 1, $ 2 $ a se refiere al grupo 2, etc. $ 0 $ se refiere a lo que sea que coincida la expresión completa. En este ejemplo, el ID que extraemos se mantiene en Person_g1, mientras que el valor del Nombre se almacena en Person_g2.
4

Match No.

Dado que planeamos extraer solo la segunda ocurrencia de este patrón, haciendo coincidir el segundo voluntario, usamos el valor 2. El valor 0 haría una coincidencia aleatoria, mientras que un valor negativo debe usarse con el controlador ForEach.
5

Default

Si no se encuentra el elemento, este será el valor predeterminado. Este campo es opcional. Puede dejarlo en blanco.

Agregue un oyente para capturar el resultado de este plan de prueba. Haga clic con el botón derecho en el grupo de subprocesos y seleccione la opción Agregar → Oyente → Ver árbol de resultados para agregar el oyente.

Guarde el plan de prueba como reg_express_test.jmx y ejecute la prueba. La salida sería un éxito como se muestra en la siguiente captura de pantalla:

JMeter tiene algunas limitaciones, especialmente cuando se ejecuta en un entorno distribuido. Seguir estas pautas ayudará a crear una carga real y continua:

  • Utilice varias instancias de JMeter en caso de que la cantidad de subprocesos sea mayor.

  • Verifique las reglas de alcance y diseñe en consecuencia.

  • Utilice convenciones de nomenclatura siempre para todos los elementos.

  • Compruebe la configuración de conectividad predeterminada del navegador antes de ejecutar los scripts.

  • Agregue oyentes de manera apropiada.

  • Aquí hay algunas sugerencias para reducir los requisitos de recursos:

    • Utilice el modo sin GUI: jmeter -n -t test.jmx -l test.jtl.

    • Utilice la menor cantidad de oyentes posible; si usa el indicador -l como se indicó anteriormente, todos pueden eliminarse o desactivarse.

    • Desactive el oyente "Ver árbol de resultados", ya que consume mucha memoria y puede provocar que la consola se congele o que JMeter se quede sin memoria. Sin embargo, es seguro utilizar el oyente "Ver árbol de resultados" con solo "Errores" marcados.

    • En lugar de usar muchos muestreadores similares, use el mismo muestreador en un bucle y use variables (conjunto de datos CSV) para variar la muestra. O tal vez utilice Access Log Sampler.

    • No utilice el modo funcional.

    • Utilice la salida CSV en lugar de XML.

    • Guarde solo los datos que necesite.

    • Utilice la menor cantidad posible de afirmaciones.

    • Desactive todos los gráficos de JMeter ya que consumen mucha memoria. Puede ver todos los gráficos en tiempo real utilizando la pestaña JTL en su interfaz web.

    • No olvide borrar la ruta local de CSV Data Set Config si se usa.

    • Limpie la pestaña Archivos antes de cada ejecución de prueba.