Quantcast
Channel: Abstracta Blog
Viewing all 48 articles
Browse latest View live

Tips para mejorar tu script JMeter

$
0
0
Desde hace un tiempo venimos trabajando en entregar a nuestros clientes scripts de JMeter que les permita ejecutar de manera rápida y sencilla sus pruebas de performance con la ayuda de BlazeMeter.
Sabemos que muchas veces estos scripts son ejecutados por equipos que no necesariamente tienen un entrenamiento en JMeter pero aún así muchas veces desean tener la posibilidad de aplicar modificaciones y entender el script que les estamos entregando.


Para esto estamos, desde hace un tiempo, trabajando en construir scripts que resulten intuitivos y comprensibles para quien no es un experto en JMeter y que puedan sin mayor dificultad leer, entender y modificar nuestros scripts para luego ejecutarlos desde BlazeMeter.

Es así que a partir de este trabajo hemos construido una checklist la cual revisamos antes de entregar cualquier script. Esta checklist reúne una serie de buenas prácticas las cuales hoy queremos compartir con ustedes.

  1. Eliminar todos los elementos de log

Muchas veces agregamos en nuestro script elementos de log para poder debuggear cualquier error que pueda surgir en el proceso de construcción del script, pero una vez terminado el script, antes de entregarlo, conviene quitar estos elementos para que esto no impacte en la performance de la generadora de carga (máquina desde la cual se ejecuta la simulación de la carga, de los usuarios virtuales concurrentes con JMeter). Hay casos en los que el script de por sí utiliza muchos recursos de la máquina generadora de carga, pero si además le agregamos que esté siempre escribiendo en disco cada request y response agregamos una carga innecesaria.

  2. No agregar pedidos secundarios

Todos aquellos pedidos que se caracterizan por ser estáticos y que vienen como recurso embebido de un pedido primario (imágenes, archivos css, javascript, etc.), no son necesarios en los scripts. Esto es porque en JMeter, entre las opciones de un elemento HTTP Request correspondiente a un pedido primario, podemos habilitar la opción Retrieve All Embedded Resources que genera el siguiente comportamiento:
  • Se envía en pedido primario (el del HTTP Request en cuestión)
  • Al obtener la respuesta (archivo HTML) se parsea y se buscan automáticamente todos los recursos embebidos en el HTML
  • Para cada elemento reconocido se ejecuta un HTTP Request. 
De esta forma se reacciona con más precisión que si se establecieran a priori los pedidos secundarios en forma pre-programada en el script. Incluso considerando que esto implica mayor procesamiento en la máquina generadora de carga, consideramos que es muy beneficioso para el mantenimiento de las pruebas y la mejor simulación de un usuario real.

  3. Agregar un nombre representativo al Thread Group.

El nombre con el que nombramos el elemento Thread Group debe ser representativo al caso de prueba o flujo que se está automatizando. Con esto ayudamos al cliente a analizar un script que no tiene un nombre que solo el tester entiende sino que lo puede entender cualquiera que esté involucrado con el caso de prueba.

  4. Agrupar por grupo de acciones.

Todo guión de prueba se compone de una serie de acciones de usuario, por ejemplo: Cargar el sitio, login, click en ofertas, seleccionar un artículo, comprar artículo, confirmar la compra. Todas estas acciones involucran un conjunto de pedidos HTTP que pueden ser agrupados en bloques mediante el uso de Transaction Controller al cual se le puede configurar un nombre de controlador.Recomendamos que ese nombre sea el mismo a la acción que está englobando para que el cliente pueda fácilmente tener trazabilidad entre el guión de pruebas y el script. Por ejemplo:


Observar que además estamos cumpliendo lo indicado en el punto 3.

  5. Verificar la inclusión de pedidos a servidores externos.

Hay veces que, al realizar una acción en la aplicación, se desencadenan pedidos que no necesariamente son al host de la aplicación. En estos casos siempre conviene corroborar con el cliente si es de su interés analizar la performance de este host (o sea, si ese host también es parte del SUT - sistema bajo pruebas), porque en el caso que no lo sea ese pedido HTTP se puede omitir ya que no genera tráfico al servidor que se está queriendo evaluar y evitamos tener pedidos en nuestro script que no son necesarios.
Ejemplo: banners de publicidades traen cosas de Facebook, Google Analytics, Twitter, etc.

  6. No incluir redirecciones.

Los redirect son pedidos que son ejecutados por redirección de un pedido HTTP anterior a éste. Típicamente al ejecutar un pedido HTTP, el código de respuesta del pedido es un 301 o 302 que en el header de la respuesta viene un parámetro Location con la URL a la que se debe redirigir el pedido. En JMeter no es necesario generar un HTTP Request para estos pedidos ya que en el HTTP Request del pedido, llamémosle padre:

se puede habilitar la opción Follow Redirects que van a hacer esta tarea por nosotros.


De esta forma es más fácil manejar las redirecciones, el script queda más fácil de entender, despreocupándonos de las idas y vueltas que pueden llegar a haber luego de un pedido. De otro modo habría que parsear el header de la respuesta mediante el uso de expresiones regulares y creando un HTTP Request manualmente.

  7. Incluir validaciones en todos los pedidos HTTP primarios

Las validaciones o Response Assertion en JMeter son la manera que tenemos de validar que la respuesta que estamos obteniendo del servidor es correcta. La herramienta solo verifica el código de respuesta, y si no es un error 5XX o 4XX dirá que fue correcta, pero tal vez se pierde de muchos otros problemas que puedan ocasionarse, con lo cual es necesario hacer una mínima validación que nos asegure que estamos siguiendo el flujo que queremos.

Buscar qué validar en una respuesta es todo un arte, no hay un manual que trate este tema, por lo que lo podemos dejar para discutir en un próximo post :). Lo importante aquí es que no puede faltar en ningún pedido HTTP Request el correspondiente Response Assertion.

Y ya que estamos con las validaciones, me gustaría además agregar un detalle que se da en los casos de redirección. Cuando se nos presenta un redirect, en el request padre (Darth Vader) debemos validar lo que sería la respuesta del último pedido que fue desencadenado por el redirect y no la respuesta del pedido padre. Esto es un detalle que JMeter lo valida así automáticamente, pero es mejor si sabemos cuál es el comportamiento ante estas situaciones.

  8. Usar HTTP Request Defaults

Todos los elementos de configuración HTTP Request tienen su espacio para configurar el server y el port, entre otros. Por un tema de practicidad nunca es bueno dejar este valor hardcode ya que si el script es extenso y nos cambian estos valores al momento de ejecutar, ya que es muy común que automaticemos en un ambiente de pruebas y luego ejecutemos en distintos ambientes, en pruebas, pre-producción, producción, en distintos entornos de diferentes clientes, etc, es una tarea engorrosa ir pedido por pedido cambiando estos valores. Para que se hagan una idea, en mi último proyecto teníamos 14 scripts con 40 a 50 requests cada uno. Para prevenir esta situación, hacemos uso de del elemento de configuración HTTP Request Defaults. En este elemento vamos a poder configurar el server y port por defecto al cual querramos que vayan los pedidos de nuestro script y de esta manera, si en todos los HTTP Request dejamos en blanco los valores de server y port el pedido se va a dirigir a los que se especifiquen en el HTTP Request Defaults. Es una manera sencilla para que luego el cliente sepa dónde configurar estos parámetros.


Aún seguimos trabajando en esta checklist así que los animamos a que nos compartan sus experiencias y nos ayuden a mejorar esta lista. Esperamos que este artículo les haya sido de utilidad.


Automatizando con JMeter ¿Qué puedo validar en la respuesta de un HTTP request?

$
0
0
Para quienes trabajamos con JMeter y con pruebas de performance, sabemos de la importancia de agregar validaciones a todos los HTTP Request. Las validaciones no solo son una manera de corroborar que el servidor está respondiendo de manera esperada, sino que nos sirven también para verificar que el script que estamos desarrollando está actuando como lo debe hacer, que está simulando el comportamiento de los usuarios tal como fue diseñado.

Por ejemplo, si el impacto de nuestro script en el sistema implica que se cree un registro en la base datos, nos tenemos que asegurar que no ocurra que luego de ejecutar el script no se haya creado el registro, y que el script diga que terminó sin problemas.. Estos son ejemplos de malas elecciones de assertions o validaciones en nuestro requests.

En otras palabras, lo que necesitamos es evitar falsos negativos y falsos positivos. Recordemos que en el post “¿Probar un caso de prueba? ¿test del test?” se hizo una introducción a estos conceptos:
  • Falso Positivo: la prueba dice que hay error y no lo hay, entonces perdemos tiempo buscando la causa del error hasta que nos damos cuenta que el error estuvo en el test, en el ambiente, los datos, etc.
  • Falso Negativo:¡hay errores y nosotros tan tranquilos! confiados de que esas funcionalidades están cubiertas, que están siendo probadas, y por lo tanto que no tienen errores (ojo!!)
Es decir, si hay un error, el script tiene que fallar, si anda bien, el script tiene que decir que anduvo bien y nosotros tenemos que poder confiar en ello.

Pero, ¿cómo hacemos para seleccionar buenos assertions? La realidad es que no he encontrado una guía de cómo elegirlos, y es un tema que siempre me cuesta explicar cuando estoy enseñando a alguien a usar JMeter y me preguntan ¿cómo elijo qué validar?

Como mencionamos en el post Tips para mejorar tu script JMeter, validar un código de respuesta no es suficiente, ya que nos podemos perder de otros errores que necesitamos capturar para poder actuar al respecto. Por esto, me gustaría compartir con ustedes los métodos y criterios que me han dado más resultado a la hora de seleccionar qué validar en la respuesta de un servidor.

1 - Validar un login

Típicamente, luego de autenticarnos en un sistema nos aparece algún texto de “Bienvenid@ NombreUsuario” o aparece nuestro nombre por algún lado de la pantalla, indicando que el login fue exitoso, por lo que en estos casos es un excelente elemento para validar.

Veamos esto con un ejemplo:


Recordemos que en JMeter en las validaciones podemos especificar una variable, entonces en los casos que el nombre del usuario está parametrizado (es leído de un archivo de tipo csv o definido como variable de usuario), puedo validar el texto ${NombreUsuario} y JMeter se encargará de reemplazar la variable por su valor.

2 - Validar contenido de la ventana

Otras muchas veces el request que hacemos nos devuelve una página de la que podemos escoger textos/títulos que deban venir en el HTML de la respuesta. Por ejemplo, si accedo al sitio de JMeter
(http://jmeter.apache.org/) podemos ver lo siguiente:


Por lo que sabemos que si este sitio carga de forma correcta el título “What can I do with it?” debe venir como respuesta al pedido realizado al sitio. Entonces, es un buen assertion para agregar como validación de que estamos recibiendo la página esperada.

El desafío en este tipo de validaciones está en validar contenido que sepamos que, en caso de haber un error, dicho texto no viene como respuesta. Para esto podemos recurrir a los desarrolladores para que nos aporten este tipo de información.

3 - Tener en cuenta próximos pasos del script

Si sabemos que la próxima acción a realizar es clic en un botón X, o acceder al link Z, o seleccionar la opción A del combo B, una muy buena estrategia es validar que en la respuesta del request venga ese elemento sobre el que queremos accionar en el próximo paso. Por ejemplo si luego de cargar el sitio de JMeter quiero seleccionar la opción de “Download Releases” puedo validar este texto y me aseguro la continuidad del flujo.


Para esto recurro a la captura de la respuesta del servidor y compruebo como viene dicha opción:



Y luego creo la validación en JMeter:


4 - Validar valores que necesito extraer

Hay veces que de la respuesta de un HTTP Request obtenemos variables a través del uso de Expresiones regulares (Add -> Post Processors -> Regular Expression Extractor) con la intención de usar esa variable en un pedido posterior.


Podemos entonces validar que dicha variable aparezca en la respuesta del servidor.
Para esto podemos hacer uso de validaciones que utilicen expresiones regulares.
Por ejemplo:


De este modo, si la expresión regular no matchea en la respuesta recibida, vamos a obtener un error de validación.

5 - Cuidado especial: caracteres especiales

Hay que tener cuidado a la hora de escribir el assertion en JMeter porque no siempre se recibe el texto en el mismo formato que se muestra en pantalla, por ejemplo si quisiera validar el título Apache JMeter™, no lo puedo escribir de manera textual porque en la respuesta del servidor viene como: Apache JMeter™ y no del otro modo como se ve en pantalla. Si no utilizamos el texto tal como aparece en el HTML, la validación (así como las expresiones regulares) no lo encontrarán.

6 - La cantidad adecuada de assertions

JMeter permite agregar tantos assertions como el usuario quiera, por lo que cada uno de los assertions que se nombraron antes pueden ir acompañados por otros assertions como por ejemplo los títulos de las respuestas de tipo HTML (<title>...</title>), con el fin de agregar robustez a la validación.A la hora de agregar más assertions tenemos que tener cuidado que el script no quede muy cargado, es por esto que no se aconseja agregar más de dos assertion por cada request, por lo cual tenemos que asegurarnos que los que escojamos sean determinantes a la hora de definir la correctitud de la respuesta.

Esperamos entonces que esta lista les sea de utilidad a la hora de agregar assertions y que nos compartan otras ideas que ustedes suelan usar como testers de performance para complementar a éstas.

Certificación en Performance Testing con Jmeter + Blazemeter

$
0
0
Tenemos un descuento especial para los lectores del blog, brindando un 10% debajo del precio de lista. Se trata de un curso y certificación en pruebas de performance con las herramientas JMeter y BlazeMeter.

Recientemente nos asociamos con BlazeMeter, conocida por ser la herramienta más usada para pruebas de performance desde el Cloud, permitiendo simular hasta un millón de usuarios concurrentes y pagando por uso. Esta herramienta brinda una facilidad y flexibilidad para realizar pruebas que sin ella serían muy complicadas de realizar, considerando los costos de infraestructura y el armado de ambientes de testing. Para poder preparar la simulación de carga esta herramienta utiliza scripts hechos con JMeter, con lo cual es necesario manejar ambas herramientas para hacer las pruebas de carga que se nos antojen.

Gracias a esta asociación, en Abstracta estamos dando la posibilidad de aprender y certificarse en el uso de ambas herramientas de la mano de expertos, comenzando con los conceptos principales sobre pruebas de performance, utilizando las herramientas más populares de la actualidad.

Si te interesa, el curso comienza el 23 de marzo, y hay tiempo hasta el 20 de marzo para registrarse. El precio del curso es de 250 dolares por persona, pero para los lectores del blog estamos dando dos formas de obtener un descuento:

  • Al momento de registrarte, utilizando este promocode: PerfMatters obtenés un 10% de descuento.
  • Si sumás a 3 amigos, el curso te queda gratis.




Importante: el material del curso en esta primera edición es totalmente en inglés, así que se requiere poder leer y escuchar inglés. Luego las clases en vivo serán dictadas en español y en inglés, a elección.

Para más información entrá en http://abstracta.us/performance-testing-certification/

Javier Garzás en Montevideo, inscribite al curso de testing ágil y deuda técnica (cupos limitados)

$
0
0
Tengo el agrado de comentarles que Javier Garzás (conocido mentor ágil, profesor titular de la Universidad Rey Juan Carlos, una de las Universidades de referencia en Madrid) estará la última semana de Abril en Montevideo, ya que dará una keynote en el TestingUY. Aprovechando su visita, organizamos un curso de Testing Ágil y Deuda Técnica, con opción a certificación.



El curso tiene una duración 8 horas a realizarse el viernes 29 de Abril, de 9 a 18.30 (con una hora y media de pausa para almuerzo). La misma actividad se realizará también en el mismo esquema el sábado 30 de Abril.

Costos:
  • Early bird (antes del 10 de abril): 150 dólares más IVA.
  • Late registration (desde el 11 de abril): 200 dólares más IVA. 
Promociones:

  • Si sos cliente o partner de Abstracta, y estás interesado en el curso, escribime para conversar (federico.toledo@abstracta.com.uy). 
  • Si traés a 3 amigos que se inscriban, tu entrada es gratis

Solo hay 40 lugares disponibles (20 cada día), así que no te duermas :)

Para realizar el pago, deben registrarse el sitio de Eventbrite y comuníquese con secretaria@abstracta.com.uy, o al teléfono (00598) 2709 6613 de lunes a viernes en el horario de 9 a 18 horas.



El curso se realizará en las oficinas de Infragistics (¡¡gracias Andrés y Claudia!!) - Echevarriarza 3333, Montevideo 11300, Uruguay.


DESCRIPCIÓN DEL CURSO
El Testing Ágil como práctica profesional, está siendo cada vez más requerida por las empresas que trabajan bajo un desarrollo ágil (por ejemplo Scrum). El propósito del curso es aprender una práctica para hacer pruebas software siguiendo los principios del desarrollo ágil. Para ello se introducirá en la automatización de pruebas web y móviles utilizando prácticas como TDD y BDD (entre otras técnicas) con el objetivo de entregar valor para el negocio, en intervalos frecuentes, trabajando a un ritmo sostenible, todo ello bajo un ciclo de vida ágil iterativo e incremental con iteraciones cortas.

SOBRE JAVIER GARZÁS
El curso es dictado por el Doctor en Informática Javier Garzás, de España.
Mentor Ágil, experto en gestión de proyectos y equipos, cuyo primer proyecto ágil fue en 2001. Hasta la fecha ha ayudado ya a más de 80 empresas. Actualmente, dedicado a ayudar a las empresas, a que hagan mejor software (en tiempo, con productividad, con calidad, y felicidad). Colabora activamente con la empresa – comunidad 233 Grados de TI y, además, es profesor titular de la Universidad Rey Juan Carlos (una de las Universidades de referencia en Madrid).
Ha sido programador, jefe de proyecto, consultor, director de informática, diseñador, ha pasado por casi todas las dedicaciones del desarrollo software.
En lo que refiere a formación, postdoctorado e investigador invitado en la Universidad Carnegie Mellon (Pittsburgh, EE.UU), Doctor (Ph.D.) (cum laude por unanimidad) e Ingeniero Superior en Informática (premio extraordinario) por la UCLM.



    TEMARIO DEL CURSO

    PARTE 1. EL TESTING ÁGIL
    • ¿Por qué cada vez se pide más el Testing Ágil?
    • Qué es Testing Ágil
    • Testing "no fase" y "sí tarea" (ciclo de vida ágil y el Testing)
    • El equipo multifuncional ágil y el Tester
    • DoD

    PARTE 2. DEUDA TÉCNICA
    • ¿Qué es la Deuda Técnica?
    • Diferentes Maneras de ver la calidad software
    • Métricas
    • De dónde viene la Deuda Técnica

    PARTE 3. "Overview" de Prácticas Típicas en Testing Ágil y Deuda Técnica
    • ATDD, BDD, Gherkin, Cucumber, TDD
    • DevOps
    • Entornos


    Opcionalmente, pagando 60 dólares extra se accede a una certificación por la asistencia y el rendimiento del alumno dentro del curso. Más info de la certificación acá.


    Tuve el placer de asistir a una charla de Javier en el VLCtesting, en el 2013, cuando estaba haciendo el doctorado en España. Además, ambos formamos parte de la mesa redonda con la que se cerró la conferencia. Su forma de exponer es bien entretenida, bien explicativa, con lo cual confío en que los cursos serán del mismo nivel de excelencia. Desde entonces leo con frecuencia su blog, donde comparte experiencias bien interesantes, así que si no lo lees, te recomiendo lo hagas aquí: www.javiergarzas.com. Si quieres ver alguna ponencia, puedes buscar varias en youtube, aquí te dejo una.




    Esta actividad es un esfuerzo de Abstracta para poder contar con un expositor de tal talla en el evento que con la voluntad de varias empresas, de varios sponsors, y de toda la comunidad de testers, ha logrado crecer notoriamente.

    PROMO Libros para TestingUY

    $
    0
    0
    Se acerca el TestingUY, el lugar donde los testers de Uruguay y la región podemos intercambiar experiencias y conocimiento. Como parte de esto, daremos más facilidades para acceder a libros bien interesantes sobre gestión ágil de Javier Garzas, quien estará en Uruguay durante la semana del TestingUY, dará una Keynote, y además estaremos ofreciendo sus cursos de testing ágil con certificación (si estás interesado en el curso, hay cupos limitados así que registrate cuanto antes).

    Los libros que podemos tener a disposición para el TestingUY son:



    portadaGestionAgilPortada_logo_derechaLetras

    Cada uno tiene un precio de 19,9 U$S, pero el amigo Javier nos ofrece un 10% de descuento, y lo trae desde España, por lo que quedarían en 17,90 U$S.

    Si te interesa alguno de estos libros es NECESARIO que nos indiques, comunicándote conmigo federico@abstracta.us, antes del 21 de abril. 

    Sumándonos a esta movida, ofreceremos el libro de Introducción a las Pruebas de Sistemas de Información a solo 100 pesos. Esto será solo desde hoy hasta el día del TestingUY. 


    Si quieres uno, es solo pasar a buscarlo por nuestras oficinas, o el día del evento. 

    3ra edición de TestingUY - Abstracta te invita a charlas y talleres: test de accesibilidad, testing ágil y testing exploratorio

    $
    0
    0
    Por tercer año consecutivo Abstracta participa activamente en la organización del evento más importante de Testing de América Latina, el cual además es gratuito para todos los participantes, y contará con exponentes de España, Estados Unidos, Argentina y Uruguay. Se llevará a cabo el próximo 26 y 27 de abril en la Facultad de Ingeniería de la Universidad de la República. Toda la información está en www.testing.uy.

    En este post los queremos invitar a participar de las charlas y talleres que brindará el equipo de Abstracta, y en especial a uno en el cual se abordará una temática que hasta ahora no se había abordado, y que en años anteriores recuerdo que se había nombrado y preguntado, mostrando interés por el tema: pruebas de accesibilidad.

    Para entender mejor la información que motiva a participar de un taller así, les compartimos esta infografía preparada por Lisandra Armas y Ayessa Melgar de Abstracta:



    Más datos del taller

    • Requisitos: el participante debe traer su smartphone o tablet.
    • Resumen: Vivimos en un mundo donde la tecnología móvil ya es parte de nuestras vidas. En el 2014 Google Play contaba con 1.43 millones de aplicaciones en el mercado y App Store con 1.21 millones de aplicaciones, pero ¿cuántas son accesibles para personas discapacitadas? Existen más de mil millones de personas que viven en todo el mundo con alguna forma de discapacidad; de ellas, casi 200 millones experimentan dificultades considerables en su funcionamiento. Cuando una compañía lanza una aplicación al mercado debe considerar la accesibilidad como un factor importante ya que la población está envejeciendo y el riesgo de discapacidad es superior entre los adultos mayores, y también al aumento mundial de enfermedades crónicas. El objetivo del taller es promover la importancia de las pruebas de accesibilidad en aplicaciones móviles para lograr un producto accesible para todas las personas.

    Más datos de Lisandra

    Ingeniera informática graduada en la Universidad de las Ciencias Informáticas (UCI) de Cuba. Cuenta con siete años de experiencia en pruebas funcionales, usabilidad, rendimiento y accesibilidad. Ha realizado publicaciones de artículos de testing referentes a las pruebas de software y accesibilidad en sitios web. Ha cursado posgrados sobre diseño de Pruebas, evaluación de la Seguridad, Usabilidad y Eficiencia en productos de software. Recibió un diplomado en Sistema de Gestión de la Calidad de los Servicios. Certificó el curso Testing Funcional impartido por el CES. Actualmente se encuentra realizando pruebas a aplicaciones móviles y web.
    • Twitter: @ArmasLisy1988
    • Linkedin: https://uy.linkedin.com/in/lisandra-armas-águila-79bb22ab





    Además, te recomendamos este taller, que daré sobre testing exploratorio:

    16.30 – 18.30 SALÓN 720 – TALLER DE TESTING EXPLORATORIO – Federico Toledo
    Resumen: Para que no te queden dudas de los beneficios del testing exploratorio, haremos una dinámica en la que todos lo pondremos en práctica para poder visualizar la estrategia completa y los beneficios y aplicabilidad que tiene. Lo más importante, nos divertiremos y así entenderemos cómo el testing exploratorio ayuda a romper el mito de que el testing es aburrido.

    Federico Toledo
    Doctor en Informática por la UCLM en Ciudad Real, España. Socio fundador de la empresa Abstracta (www.abstracta.com.uy) dedicada al testing de software (servicios y productos). Con más de 10 años de experiencia en consultoría, investigación y desarrollo vinculado al área de testing (funcional, automatizado y performance). Es autor de uno de los primeros libros en castellano sobre testing llamado “Introducción a las Pruebas de Sistemas de Información”. Docente de la Universidad Católica del Uruguay, y director académico de Abstracta Academy, plataforma de e-learning con cursos de testing de software. Colaborador del Proyecto Social y Educativo Nahual (nahual.uy). Organizador de la conferencia más importante de testing en Latinoamérica (testing.uy).
    • Twitter: @fltoledo
    • Linkedin: https://uy.linkedin.com/in/federicotoledo




    El día siguiente, el 27 de abril, será un día completo de charlas, donde esperamos que asistan más de 250 personas. Puedes anotarte en testinguy3.eventbrite.com.

    Aquí está el programa completo http://www.testing.uy/#charlas

    En particular te quiero invitar a las dos charlas que arrancan el evento:


    10:30 – 11:00 – LA MUERTE “ÁGIL” DEL TESTER– Gabriel Montero, Federico Toledo
    ¿El rol del tester está destinado a morir a causa del Agilismo? Si seguimos haciendo las mismas cosas que hace 20 años atrás, probablemente sí. Marcos de trabajo ágiles como Scrum se han convertido en algo que va más allá de la gestión de proyectos, re-definiendo nuestra concepción del trabajo, apuntando al trabajo en equipo y sus interacciones, por encima de roles especialistas. ¿Esto quiere decir que debamos prescindir de roles más específicos como el Tester?. No, por el contrario, nuestra charla intentará reflexionar a partir de nuestra experiencia empírica sobre el cambio de paradigma. De esta manera, buscamos ampliar la concepción de Tester enfocado únicamente al Diseño o Ejecución de Casos de Prueba, en pos de personas más “full stack”, debiendo incorporar nuevas formas de testear software como el Testing Exploratorio, y elementos de Gestión claves para generar entornos de confianza y colaboración, que nos permitan entregar productos de mejor calidad en un “time to market” adecuado a nuestros clientes.



    Y por último, sobre el final del día habrán varios sorteos, donde estaremos regalando descuentos en nuestra certificación de JMeter y BlazeMeter, así como algunos libros de testing.

    ¡¡¡Los esperamos!!!

    Solo para mujeres: ¡Techy por el día!

    $
    0
    0
    Nos sumamos a la iniciativa de la CUTI "Techy por el día".

    Desde 2014, Cuti se suma a la celebración mundial de las Girls in ICT, un día para sensibilizar sobre la carencia de mujeres en la industria e incentivar para que más chicas consideren su futuro en las tecnologías. 

    Abstracta abre sus puertas el día 28 de abril para que todas aquellas adolescentes que quieran tener un primer acercamiento al mundo de la tecnología, conozcan lo que hacemos y lo que pueden realizar ellas el día de mañana.




    La propuesta consiste en:
    • Bienvenida (lo haremos en dos tandas, a las 9.30hs la primera y a las 11hs la segunda).
    • Una recorrida guiada por nuestras instalaciones.
    • Dinámica inicial.
    • Charla con mujeres referentes de la empresa compartiendo su experiencia y trayectoria con un desayuno compartido.

    Confirmar asistencia a: elisa@abstracta.com.uy



    ¡¡¡Las esperamos!!!

    Mujeres en la informática - Techy por el día, iniciativa de CUTI apoyada por Abstracta

    $
    0
    0
    Tal como les anunciamos la semana pasada, Abstracta abrió sus puertas el día 28 de abril para que todas aquellas adolescentes que quieran tener un primer acercamiento al mundo de la tecnología, conozcan lo que hacemos y lo que pueden realizar ellas el día de mañana.


    La propuesta es iniciativa de la CUTI, en una jornada que implica el incentivo y la sensibilización sobre la carencia de mujeres en la industria. Es parte de una movida más grande llamada Girls in TIC (aquí hay un detalle más claro de lo realizado a nivel mundial en esta fecha).


    Se presentaron cerca de 30 jóvenes, algunas de ellas se enteraron del evento a través de Abstracteros, otras a través de las redes sociales, pero la gran mayoría fueron alumnas de la Escuela Superior de Buceo (¡gracias Vicky por el contacto!).

    La jornada comenzó con una dinámica inicial para romper el hielo, para conocernos, presentarnos y definir el interés personal de cada una dentro del área de informática y tecnología. 

    Continuamos con una dinámica en grupos, cada grupo tenía que realizar mediante collage qué se imaginan de lo que es e implica el mundo IT. Luego un representante de ambos grupos presentó las ideas plasmadas en papel. 


    Finalizamos la jornada con un desayuno en el que algunas Abstracteras se sumaron para contar su experiencia y rol dentro del a empresa, su trayectoria en el rubro y derribar algunos mitos del mundo IT que hay en el imaginario colectivo (¡Gracias Leti, Vicky, Eli y Sofi!). Se dejó abierto luego un espacio para poder evacuar preguntas. 

    Luego de la Jornada, nos contactaron de la Escuela Superior de Buceo para comentarnos el gran impacto que generamos en estas jóvenes con la apertura a un mundo nuevo para ellas. ¡Esperamos poder continuar contribuyendo con futuros acercamientos!


    Para terminar, un gran agradecimiento a Elisa (una de las tantas chicas de Abstracta), por llevar adelante esta actividad, organizarla, recibir a las chicas, y por escribir este post. ¡Imponente!

    TestingUY 3 - Resumen de lo que fue el evento más grande de testing de la región

    $
    0
    0
    Les quiero resumir un poco cómo fue la semana del TestingUY y cómo eso ha generado muchas buenas oportunidades para los testers de Uruguay y la región. Han sido unos días intensos, recién ahora puedo ponerme a escribir al respecto, pero realmente la experiencia completa fue muy gratificante por todos los buenos resultados que considero que tuvo.
    El evento se realizó el 26 y 27 de Abril, y fue su tercera edición. Este año, con el equipo organizador, hicimos varias apuestas para hacer crecer el evento:
    • Oradores internacionales como Javier Garzas (de España) y Kevin Richardson (de USA).
    • Traducción simultánea para la charla en inglés.
    • Grabación de charlas para que quede registro útil también para los que no pudieron asistir.
    • Más talleres.
    • Variedad de temas. 
    • Evento social.
    • Sitio web en dos idiomas (español e inglés).

    Además, como en Abstracta nos hicimos cargo de invitar a Javier y organizar todo lo relacionado a su viaje, organizamos un par de eventos para aprovechar su visita y ofrecer más cosas a la gente de la región:
    • El lunes 25 de Abril organizamos un pequeño evento donde Javier estuvo hablando de "Gestión ágil de proyectos" y yo aproveché a ser su telonero hablando de la importancia de la calidad y el testing en todos los aspectos de cualquier proyecto (aquí les comparto las ppts que utilicé). Asistieron alrededor de 40 personas.
    • Como les comenté varias veces por redes sociales, organizamos un curso de "Testing ágil y deuda técnica", el cual lo tomaron casi 40 personas y todas dieron un feedback muy positivo sobre el curso, especialmente por la habilidad de Javier de introducir el tema en forma muy amena. Revisando el feedback que recogí todos calificaron con 4 o 5 estrellas (de un total de 5, aclaro por las dudas jeje).
    • Además, dimos la posibilidad de comprar dos de los libros de Javier a un precio en oferta, y él mismo se encargó de traerlos para los interesados. 

    El evento se llevó a cabo en la Facultad de Ingeniería de la Universidad de la República, el día 26 fueron talleres que se realizaron en el 7mo piso de la Fing, y el 27 fueron las charlas, que se hicieron en el aulario.

    El primer día asistieron más de 180 personas a los siguientes talleres:
    • Test con usuarios
    • Implementar seguridad como tarea de testing: DAST
    • Testeando la compatibilidad de software con IPv6
    • Pruebas de accesibilidad para aplicaciones móviles
    • Clínica de performance
    • Automatización de pruebas con Ruby
    • Métricas en tiempo real y automatización dinámica de pruebas
    • Probando la experiencia de usuario
    • Taller de testing exploratorio.


    En particular el "Taller de testing exploratorio" lo hice yo y para mí estuvo bien entretenido e ilustrativo, y por lo que consulté a los asistentes les resultó de valor también, con lo cual contento :) (utilicé unas ppts muy similares a estas que compartí aquí).

    También muy contento por Lisandra, parte del equipo de Abstracta, quien compartió un taller de "Pruebas de accesibilidad para aplicaciones móviles" que tuvo muy buena recepción también. Les vuelvo a compartir la infografía que armó Lisandra y Ayessa para reflejar números bastante interesantes sobre el tema:



    El evento fue un punto de reunión no sólo para gente de Montevideo, sino también para personas que vinieron de Salto (muchos de la oficina de Abstracta de Salto) y algunas que vinieron de distintos puntos de Argentina, como Buenos Aires, Córdoba y Corrientes. En total superaron las 270 personas.

    El keynote de la mañana “Testing ágil: Último capítulo del gran superhéroe” fue presentado por Javier Garzas de la Universidad Rey Juan Carlos de Madrid. El keynote de cierre del evento “Diseño, usabilidad y sistemas complejos” fue presentado por Kevin Richardson de la empresa Infragistics de Estados Unidos. Su charla fue realizada en inglés con traducción simultánea, y si bien teníamos muchas dudas de cómo resultaría esto, fue de muy buena calidad.

    Durante el resto de la jornada se presentaron diversas charlas por destacados oradores de Uruguay y Argentina, donde se compartieron experiencias y conocimiento de los siguientes temas:
    • Importancia del rol del tester en los equipos de desarrollo (aquí junto a Gabriel Montero presentamos "la muerte ágil del tester", y aquí encuentran las ppts).
    • Mejora continua en equipos de testing
    • Automatización de pruebas en la nube
    • Pruebas en dispositivos móviles
    • Modelos de buenas prácticas y estándares de testing
    • Desarrollo dirigido por pruebas en la plataforma Salesforce
    • Automatización de pruebas con Ruby
    • Pruebas de performance y carga

    La selección de las charlas no fue un trabajo fácil, ya que se recibieron 26 propuestas distintas y todas muy interesantes.

    Puedes ver más detalles y el material para descargar de los talleres y charlas

    A todos los asistentes a las charlas se les regaló blocs, lapiceras, solaperos, adhesivos (con frases muy divertidas), pines, y el material aportado por los sponsors. Este año además a todos los oradores (charlas y talleres) les regalamos como presente y agradecimiento una taza del evento y una botella de vino de bodega uruguaya.



    El miércoles al finalizar la jornada se realizó un evento social, se invitaron a todas las personas a participar. Compartimos unas cervezas y pizzas para celebrar lo lindo que habíamos pasado durante las dos jornadas :)




    TestingUy es gratuito para los asistentes gracias a las empresas que auspician el evento. En esta edición el evento ha sido auspiciado por 13 empresas y 3 media sponsors. A su vez, 17 empresas, organizaciones y universidades apoyaron la iniciativa con difusión.

    Resultados de la Encuesta realizada sobre el TestingUY 3

    Con el objetivo de mejorar el evento año a año, se realizó una encuesta a las personas que asistieron y se obtuvieron los siguientes resultados:

    ¿Cómo calificarías el evento en su totalidad?
    • Muy malo: 0
    • Malo: 0
    • Regular: 4 (5,56%)
    • Bueno: 35 (48,61%)
    • Muy bueno: 33 (44,83%)
    ¿Cómo calificarías el lugar?
    • Muy malo: 1 (1,39%)
    • Malo: 0
    • Regular: 1 (1,39%)
    • Bueno: 22 (30,56%)
    • Muy bueno: 48 (66,67%)
    ¿Cómo calificarías el coffee break?
    • Muy malo: 0
    • Malo: 1 (1,49%)
    • Regular: 6 (8,96%)
    • Bueno: 30 (44,78%)
    • Muy bueno: 30 (44,78%)

    Estadísticas

    Organización
    • 5 empresas
    Apoyo
    • 13 sponsors
    • 3 media sponsors
    • 17 empresas y organizaciones que apoyaron
    Talleres y charlas
    • 9 talleres
    • 12 charlas
    • 26 propuestas de charlas recibidas
    • Oradores de Uruguay, Argentina, España y Estados Unidos
    Asistentes
    • 270 asistentes a las charlas
    • 180 asistentes a los talleres
    • Asistentes de Uruguay y Argentina
    Twitter (estadísticas de abril - mes del evento)
    • Tweets: 116
    • 64.900 impresiones
    • 7.325 vistas del perfil
    • 109 menciones
    • 816 seguidores
    LinkedIn
    • 308 miembros
    Meetup
    • 235 testers

    Fotos

    Los amigos de GeneXus Consulting tomaron muy buenas fotos, además de las que todos fuimos tomando durante el evento. Aquí están las mejores http://www.testing.uy/#galeria-de-fotos

    Sumate o seguí enganchado en la comunidad de TestingUY

    Si querés seguir enganchado con todo lo que sucede alrededor de TestingUY:
    Otro de los grandes logros del último año fue la generación de un espacio de encuentro continuo, donde una vez cada dos meses nos juntamos a conversar sobre aspectos de testing. Aquí el resumen de charlas que tuvimos, y esperemos se sigan sumando más:


    Próximamente

    • Las charlas fueron filmadas y serán publicadas en el sitio web.
    • Se publicará un resumen en video del evento en el sitio web.
    • Más adelante notificaremos por las redes cuándo será el próximo meetup, en principio les diría que en el mes de junio.


    El error más típico en el ciclo de vida de un bug

    $
    0
    0
    Les comparto un esquema que resume un posible ciclo de vida de un bug (puede tener mil variantes de acuerdo a cómo se organice el equipo, su tamaño, etc.).


    (Gracias Giulliana y Ayessa, las chicas del equipo de Abstracta que diseñaron este precioso esquema)

    Quería también compartir en este breve post cuál es uno de los errores más típicos en la gestión de incidentes que hemos visto al trabajar con distintas empresas de distintos lugares y que trabajan siguiendo distintos enfoques (tradicional y ágil): una vez que un bug está resuelto el desarrollador lo cierra.
    La correcta gestión de incidentes incluye el doble chequeo de los problemas, yo lo reporto y alguien lo resuelve, pero el que determina que el bug está cerrado es el tester que lo reportó, una vez que es capaz de constatarlo.

    Como siempre, es posible encontrar variantes a esto que para nosotros es casi ley :) y que pueden ser válidas, como por ejemplo que alguien tenga la responsabilidad de revisar los incidentes que ingresan y decidir cuáles se corregirán y cuáles no. Esta situación también se puede resolver con el flujo típico, ya sea esa persona o el desarrollador pueden marcar como "resuelto" un incidente indicando "wont fix" (que no se arreglará), y por medio del diálogo (por la herramienta, o por otro medio) entender y resolver que esa es la decisión adecuada, para lo cual entonces el tester pasaría el incidente a cerrado como una muestra del mutuo acuerdo.

    La gestión de incidentes es un punto básico en la eficiencia de un equipo de desarrollo, y es además otro de los puntos claves donde se puede ver si la gente de testing y de desarrollo se sienten o no parte de un mismo equipo con los mismos objetivos (y con esto pongo en tela de juicio no solo a los desarrolladores, sino también a aquellos testers que se "quejan" que los incidentes no se los resuelven, cuando deberíamos tener una visión global enfocada en los objetivos de todo el equipo y entender que no hay que resolver todo sí o sí).

    Me encantaría escuchar comentarios al respecto, si siguen este esquema u otro que les resulta más útil o apropiado, problemas típicos, etc.


    Testing Exploratorio: proyecto de grado para generar metodología, herramienta y difusión

    $
    0
    0
    ¿Alguna vez escuchaste de las bondades y beneficios del testing exploratorio pero no te animaste a ponerlo en práctica? Aquí te cuento cómo te vamos a ayudar: desde hace un par de meses que comenzamos a trabajar en desarrollar una metodología y herramientas para gestionar el testing exploratorio. Este trabajo lo estamos haciendo como parte de un proyecto de grado en ORT, de Gabriela Sánchez (perteneciente también al equipo de trabajo de Abstracta) y Miguel Sánchez (también fuertemente relacionado al testing).


    Photo credit: Jose Muñoz. via Visual hunt / CC BY-SA

    La motivación y visión principal está basada en que es un enfoque subutilizado, o sea, tiene grandes ventajas que no las estamos aprovechando.

    En este post pretendo presentar el proyecto y así dar pie a una serie de artículos que escribiremos durante este año, los cuales ahondarán en distintos aspectos del testing exploratorio, así como también en análisis de herramientas existentes en el mercado, experiencias reales, buenas y malas prácticas, etc.

    Si quieren conocer algo más del testing exploratorio les dejo este post de uno de los principales creadores e impulsores y esta presentación que dí en un taller de este año en TestingUY.


    El Proyecto

    Inmersos en un contexto donde el desarrollo ágil ocupa cada vez más lugar, y donde el testing, ahora testing ágil, está integrado en el proceso de desarrollo y es responsabilidad de todo el equipo, como testers enfrentamos nuevos desafíos. ¿Cómo podemos acompañar estos cambios manteniendo un nivel de excelencia en el testing?

    El enfoque que parece adecuarse mejor a esta nueva realidad es el testing exploratorio. Este enfoque de pruebas consisten en diseño, ejecución y aprendizaje simultáneos. Sin embargo, sus dificultades de implementación son bien conocidas y datan de sus orígenes. ¿Cómo podemos venderlo a nuestros Clientes (acostumbrados a medir nuestros resultados en base a “casos de prueba”)? ¿Cómo podemos demostrar lo que estuvimos haciendo durante todas las horas invertidas en las pruebas? ¿Cómo podemos gestionar el testing exploratorio y responder a preguntas como la anterior sin cambiar las características intrínsecas de éste? ¿Cómo podemos estructurar esta práctica que enfatiza la libertad individual del tester sin que el tester pierda esa libertad, sin burocratizar el mismo?

    En el año 2000, los hermanos Bach, James and Jonathan, desarrollan una metodología para realizar el testing exploratorio, conocida como: testing exploratorio basado en sesiones. Una nueva forma de realizar testing exploratorio, probablemente la más estructurada de todas, que permite obtener información que nos ayuda a realizar esta actividad intelectualmente desafiante y enriquecedora y sobre todo comenzar a “venderla” mejor. Lean más aquí.

    Aún así, hoy en día nos seguimos enfrentando a muchas dificultades en su implementación. Dificultad para procesar la información resultante de las sesiones realizadas, para obtener datos interesantes que nos permitan fácilmente responder preguntas como: ¿Cuánto se avanzó hoy? ¿Cuánto queda por probar? ¿Cuántos días más necesitamos?

    Existen numerosas  herramientas que asisten la realización de testing exploratorio, algunas de las cuales son muy buenas, por cierto. Sin embargo, actualmente, no encontramos una herramienta open source que nos permita una gestión centralizada, un procesamiento sencillo y ágil de la información generada durante las sesiones, la rápida obtención de métricas relevantes que nos permitan una planificación acorde al contexto en el que nos encontramos hoy en día, la obtención de datos de entorno, etc.

    También se dice que el testing exploratorio es ideal para el tester con experiencia, y muchas veces hemos visto que incluso testers experientes (quizá aquellos particularmente acostumbrados a trabajar con casos de prueba) no tienen claro cómo comenzar a utilizar este enfoque.

    Entonces, surge este proyecto, el cual tiene como principales objetivos:
    • Metodología: Investigar y analizar las distintas formas de realizar testing exploratorio con el fin de conocer más sobre esta técnica para desarrollar una metodología de trabajo que se adecue lo mejor posible al contexto de desarrollo ágil.
    • Herramienta: Diseñar una herramienta que permita gestionar el proceso de testing exploratorio de comienzo a fin, desde la planificación inicial y ejecución de sesiones, hasta su posterior gestión y obtención de métricas e indicadores que permiten mejorar el testing ciclo a ciclo (sprint a sprint). También se plantea que la herramienta guíe al principiante a aplicar el enfoque eficientemente.
    • Difusión: Lograr una mayor difusión del testing exploratorio en la comunidad de testers, ya que consideramos que es un excelente enfoque y está siendo muy poco utilizado (al menos eso reveló una pequeña encuesta realizada en el 2015 en la comunidad de TestingUY)
    Como parte del tercer punto es que de ahora en más se estarán publicando en este blog algunos artículos relacionados a avances y resultados del proyecto. Queremos entonces mostrar los beneficios que tiene el testing exploratorio, la mejor forma de utilizarlo (metodología) y las herramientas que hay en el mercado hoy día, así como la herramienta opensource que se desarrollará como resultado final de este proyecto. Estos posts estarán a cargo principalmente de Gabriela Sánchez y Miguel Sánchez.

    Desde ya agradecemos todo comentario o aporte que quieran realizar, y si quieren tener cualquier tipo de colaboración especial es solo decirlo.

    Información sobre los estudiantes que llevarán adelante el proyecto

    Gabriela Sánchez, Consultora en Abstracta, compañía dedicada integralmente al testing, control de riesgos de desarrollo y puesta en producción de software. Desde hace años, apoya a empresas a adquirir software de calidad volcando el know-how de las diferentes actividades de QA y ayudando a empresas productoras a asegurar la calidad de sus productos.Docente de Gestión de Proyectos e Ingeniería de Software 2 en Universidad ORT. Título de Líder de Testing del CES. Finalizando la Carrera de Ingeniería de Sistemas. Con más de 5 años de experiencia en el área de QA de IT y en el área de Gestión de Calidad. Principales intereses: QA, Docencia e Investigación Académica.

    Pablo Miguel Sánchez, Docente de Ingeniería de Software 2 en Universidad ORT. Especialista en Informática en CCC. Realizando tareas de Desarrollo de Software. Se trata de una empresa certificada según normas de FDA, en la cual se hace especial énfasis en las tareas vinculadas a la Calidad. Cursando este año proyecto de grado de Ingeniería de Sistemas. Principales intereses: QA, Desarrollo y la Docencia.


    Mecanismo para mejorar el reporte de errores de los usuarios

    $
    0
    0
    ¿Los errores que reportan tus usuarios son imposibles de entender? O quizá pierdes mucho tiempo en idas y vueltas, malos entendidos que terminan generando hasta problemas de relacionamiento con ellos. Veremos una técnica que quizá pueda ayudarte a mejorar la comunicación mostrándoles la importancia de reportar de manera eficaz.

    Si los incidentes los reportan los testers, podemos controlar la calidad de los mismos, capacitando a los testers, buscando la excelencia del equipo y la máxima productividad en este sentido:
    • evitando los tan costosos issues rechazados,
    • evitando pedir más información,
    • evitando los "en mi máquina anda", "no es un bug", "no es importante".
    ¿Qué pasa cuando también reportan incidentes los usuarios finales (o un grupo de key-users)?


    Recientemente veíamos esto como una complicación en una de las empresas en las que estábamos brindando consultoría, y no se veía posible la opción de capacitar a estos usuarios, ya que se trataba de un grupo muy grande, distribuido, etc.

    Los usuarios tienen un issue tracker para reportar todas las incidencias, con lo cual se planteó una idea bien interesante, de agregar un enlace en la página de reporte de incidentes del issue tracker que diga algo así como:
    "¿Querés que tu incidente se resuelva más rápido y en forma más efectiva? Revisá este link para enterarte cómo hacer". 
    Y de este link llevar a una página con información sobre cómo se puede lograr que un reporte de error sea más efectivo.

    Les dejamos acá un puntapié inicial al contenido que podría tener esa página, esperando que los motive a hacerlo y los ayude, mejorando la eficacia en la resolución de incidentes:

    ***************************************

    Para registrar un incidente es fundamental tener como objetivo que el desarrollador (o la persona que le dé soporte) sea capaz de resolver el problema. Para lograr esto es conveniente considerar todos estos puntos dentro de su reporte:

    Título 
    • Dar un buen título es fundamental ya que nos sirve para:
      • mostrar reportes resumidos,
      • encontrar los incidentes cuando lo buscamos,
      • abrirlo y ya saber de qué se trata, entrar en contexto.
    Descripción
    • Es necesario ser breve y conciso al describir el problema. No hace falta escribir un tratado, pero tampoco pensar que con dos palabras la otra persona entenderá todo lo que uno sabe al respecto del problema. Debemos ayudar a entrar en contexto a la persona que trabajará en el incidente. 
    Prioridad
    • La prioridad se puede definir en base a la severidad (daño que genera) y urgencia del problema. 
    Categoría
    • Es muy útil indicar a qué módulo, componente, o sector se refiere el problema. Ayuda también a ponerse en contexto. 
    Pasos para reproducir
    • Esto es algo fundamental. Para que alguien pueda arreglar el problema, primero lo tiene que ver. Además, luego que lo arregla, debe asegurarse que ya está solucionado. Para eso es muy útil y ahorra muchas ideas y vueltas poder describir el paso a paso, con qué datos sucede y con cuáles no, con qué usuario, permisos, etc. 
    Algunos otros aspectos:

    • Es muy útil dar indicaciones de la plataforma o particularidades del ambiente (navegador, dispositivo, etc.).
    • Indicar la versión del software, así como la fecha en la que ocurrió el problema. 
    • Puede resultar muy útil adjuntar archivos, en especial capturas de pantalla, logs, etc. Por qué no, grabar un video que muestra cómo se reproduce el error. 
    Algunos aspectos generales a tener en cuenta:
    • No usar sensacionalismos. 
    • Deje de lado la pasión y emociones.
    • Intentar ser objetivo.
    • Ser lo más claro posible.

    ***************************************

    ¿Qué otra cosa se les ocurre que puede ser importante agregar? ¿Han visto esto en práctica alguna vez?

    5 gestos en iPads que un tester debe conocer

    $
    0
    0
    Cuando pruebas una aplicación para iPad, ¿qué tan seguro estás que pruebas todos los gestos que los usuarios de tu app van a intentar usar? Hablemos de algunas ideas sobre esto.

    Vivimos en un mundo donde la tecnología móvil ya es parte de nuestras vidas. A finales del 2015 a nivel mundial existían más de 3.2 mil millones de personas utilizando Internet y más de 7 millones de suscripciones móviles. Para que las aplicaciones lanzadas al mercado tengan éxito y sean utilizadas por un alto porcentaje de usuarios, debemos reducir al mínimo posible la cantidad de errores. Con la evolución de la tecnología se han ido incorporando gestos en los dispositivos móviles facilitando la interacción de los usuarios con las aplicaciones, permitiéndoles ampliarlas, minimizarlas, ocultarlas, utilizar dos aplicaciones al mismo tiempo, dividir el teclado para facilitar la escritura, cambiar entre aplicaciones, entre otras. Los usuarios se acostumbran a estas facilidades y las quieren usar en todas sus aplicaciones, con lo cual debemos probar cómo reacciona nuestra app ante estos eventos.



    En este post nos estaremos enfocando en 5 gestos en iPads que los testers debemos tener en cuenta al realizar pruebas en este tipo de dispositivo.

    Deslizar la pantalla hacia arriba con cuatro o cinco dedos

    Debemos tener varias aplicaciones activas en el iPad y visualizada la que estamos probando. Al deslizar hacia arriba con cuatro o cinco dedos la pantalla, se pasa directamente a la vista de multitarea en iOS y se visualizan en forma de cartas todas las aplicaciones que tenemos activas en el dispositivo. Se puede tocar una carta para cambiar de aplicación o deslizar hacia abajo con los cuatro o cinco dedos para volver a la aplicación que estamos probando.

    Deslizar la pantalla horizontalmente con cuatro o cinco dedos

    Esta es una forma muy parecida a la descrita anteriormente pero permite cambiar entre aplicaciones sin acceder a la vista de multitarea de iOS. Debemos tener varias aplicaciones activas en el iPad además de la que estamos probando. Al deslizar la pantalla horizontalmente hacia la derecha o izquierda podemos cambiar la vista entre aplicaciones. Luego volveríamos a visualizar la que estamos probando.

    “Pellizcar” la pantalla con cinco dedos

    Este gesto permite a los usuarios evitar tocar la tecla de Inicio en el dispositivo y poder volver a la pantalla principal en cualquier momento. Se realiza “pellizcando” con los cinco dedos la aplicación que estamos probando. Al realizar este gesto la aplicación reduce su tamaño hasta desaparecer, quedando visualizada la pantalla de inicio del dispositivo. Luego de realizado el gesto accedemos nuevamente a la aplicación a través de su icono en la pantalla de inicio del dispositivo.

    Nota: Para los que no hemos realizado este tipo de gesto, los pasos son los siguientes: abra la mano y toque con los cinco dedos el centro de la pantalla, luego cierre la mano lentamente tocando la pantalla con la yema de los dedos.

    Deslizar el dedo de derecha a izquierda para desplegar la opción Multitarea

    Se mantiene el iPad posicionado horizontalmente, se desliza un dedo de derecha a izquierda desde el panel lateral derecho para visualizar la opción Multitarea en el dispositivo. Puede ser visualizado el navegador o el cliente de correo. También podrás acceder a otras aplicaciones desde esta opción si deslizas con un dedo hacia abajo el indicador gris que se muestra en el borde superior derecho. Al desplegar esta barra lateral quedará una parte de la aplicación que estamos probando sin visualizar.

    Dividir el teclado con dos dedos

    Este gesto permite separar el teclado en dos partes. Se realiza posicionando dos dedos en el centro del teclado y se deslizan en sentido contrario hacia cada extremo. Para los usuarios que gustan escribir con los pulgares será más fácil utilizar el teclado en este modo. También puede hacerlo a través de Ajustes/General/ Teclados y cambiar el ajuste a teclado dividido.

    Los errores más comunes que podemos encontrar al realizar estos gestos son:
    • Cierres inesperados de la aplicación. 
    • Bloqueos de pantallas. 
    • Pérdidas de animaciones. (si aplica).
    • Funcionamiento incorrecto de los componentes de la interfaz gráfica de usuario (GUI). 
    • Opciones inaccesibles en el área que se visualiza al dividir el teclado. 
    Debido a la severidad de los errores y a que los usuarios en iPads pueden hacer uso de estos gestos con frecuencia, los testers debemos incluirlos en nuestras pruebas para verificar el comportamiento de la aplicación luego de ser realizados y así lograr una mayor calidad en el uso de estas aplicaciones.

    Meetup de TestingUY de junio

    $
    0
    0
    Luego del evento que nos reunió en abril, ¿no tenés ganas de juntarte de nuevo a compartir experiencias con otros testers? Por esto es que ya estamos convocando a que te apuntes al próximo meetup que será el jueves 30 de junio, en las oficinas de Infragistics (¡gracias de nuevo!) a las 19hs. El lugar de encuentro es Echevarriarza 3333 entre Osorio y Pereyra de la Luz.

    >>>>>>>>>> Ya podés inscribirte acá <<<<<<<<<<


    Aprovecho para dejarles el video de resumen de la tercera edición del TestingUY.


    Si querés recordar más sobre lo que fue el evento, por acá dejé mis apuntes: http://blog.abstracta.com.uy/2016/05/testinguy-3-resumen-de-lo-que-fue-el.html
    Dentro de poco estarán los videos de las charlas colgados en el sitio www.testing.uy


    Las propuestas que nos reunirán en el meetup del último jueves de la primera mitad del año son:

    Automatización Efectiva - Rodrigo Gómez 

    A la hora de automatizar, nos encontramos comúnmente con premisas equivocadas, y formas de trabajo que nos conducen al fracaso en la automatización de pruebas. Más allá de los lenguajes de programación, y herramientas que utilicemos, tenemos que definir qué nos conviene automatizar, qué no; y cómo organizarlo en el contexto de nuestro proyecto. ¿Qué necesitamos para comenzar? ¿Cómo empezamos? ¿Cómo logramos que nuestras pruebas automáticas sean mantenibles y mejoren a lo largo del tiempo?

    Experimentando y Explorando -Gabriela Sánchez y Miguel Sánchez 

    Si no tienes experiencia con Testing Exploratorio te esperamos para contarte de qué se trata y cómo ponerlo en práctica. Si ya tienes experiencia te esperamos para que puedas compartir con nosotros tu visión y contarnos un poco sobre las dificultades que encuentras al realizarlo. En todos los casos, te esperamos para que formes parte de un experimento de desarrollo de una herramienta open source de Gestión de Testing Exploratorio. ¡Sí, eso mismo! Como parte de un proyecto de investigación entre Abstracta y Universidad ORT, estamos trabajando en una herramientas que nos facilite la gestión del testing exploratorio, la cual estará disponible para la comunidad de testers en formato opensource. Más información sobre el proyecto, acá: http://blog.abstracta.com.uy/2016/06/testing-exploratorio-proyecto-de-grado.html

    ES NECESARIO LLEVAR NOTEBOOK. En caso que no puedan, hacen el taller junto a alguien más que haya llevado.

    Los que ya han asistido saben que también disfrutaremos de unas excelentes pizzas y algo para tomar, así que la idea está bien planteada: pasar un buen rato mientras aprendemos unos de otros sobre las formas de trabajar mejor en testing.


    Les dejo otro recuerdo del evento

    Foto credit: Nadia Cavalleri

    ¡Nos vemos!

    ¿No tienes pruebas unitarias? Comienza con IntelliTest

    $
    0
    0
    El diseñar y programar casos de prueba unitarios siempre fue una piedra en el zapato para los desarrolladores de software. Es un paso fundamental al agregar una porción de código al sistema, pero no siempre existe el tiempo o los recursos para completarlos.
    Si bien este nivel de pruebas es reconocido como una buena práctica para aumentar la calidad de código, también es cierto que cuando uno diseña, planifica y se mentaliza en realizar una tarea de programación, muchas veces quiere comenzar con la misma cuanto antes y deja de lado otros aspectos que no considera fundamentales. Tal vez ese sea el problema de fondo: no se consideran las pruebas unitarias como parte del desarrollo y terminan siendo una actividad de apoyo que se concreta opcionalmente.

    Para mitigar esta problemática que suele ser habitual, Microsoft Visual Studio nos presenta una herramienta que agiliza y automatiza el diseño y desarrollo de las pruebas unitarias: IntelliTest (el antes conocido como Smart Unit Tests). Esta herramienta nos ahorra un tiempo considerable en esta etapa, ya que con un par de clics podemos contar con un conjunto de pruebas unitarias en nuestra solución que logran cubrir ciertos flujos de ejecución.

    En este post Nicolás Darriulat nos comparte información sobre la herramienta, dado que la ha estado utilizando en algún proyecto en Abstracta, aportando a la automatización de pruebas a nivel unitario. El disparador inicial del uso de esta herramienta, y de la necesidad de colaborar con pruebas unitarias, surge en un enfoque que consideramos muy buena práctica, planteado por Mike Cohn, donde básicamente queda claro que para contar con un conjunto de pruebas automatizadas eficiente no es suficiente con tener pruebas a nivel de UI, sino que lo mejor es tener buenas pruebas unitarias, algunas pruebas a nivel de API, y por último, los casos más críticos automatizados a nivel de interfaz gráfica.

    IntelliTest en acción

    Veamos un ejemplo de cómo funciona IntelliTest con el siguiente método:



    Lo primero que hacemos es clic derecho sobre la firma del método, y seleccionamos “Ejecutar IntelliTest”.










    ¡Voilá!  Por arte de magia, vemos cómo se combinaron los distintos flujos del método creando cuatro casos de prueba distintos, habiéndose ejecutado todos exitosamente.




    En la columna number, se ven los distintos valores utilizados para este parámetro, y en resultado, el resultado retornado por el método en cada ejecución.

    Como se puede apreciar, al seleccionar un caso, se despliega un panel mostrando el código temporal que se utilizó al realizar la ejecución. IntelliTest nos da la opción además de guardar ese código si lo deseamos, generándonos en ese caso una nueva clase en donde se agrega ese método de prueba codificado. Es así como logramos incrementar nuestro conjunto de pruebas automatizadas a nivel unitario. 

    El criterio utilizado para determinar si un caso de prueba se ejecutó exitosamente, es si la ejecución lanzó una excepción o no, siendo fallida si el método lanzó una excepción no controlada. Naturalmente, una forma de aprovechar este criterio de éxito o falla puede ser ejecutar IntelliTest una vez que consideramos finalizada la codificación del método, y de esta forma entender si hay casos de borde o excepción que no estamos teniendo en cuenta, ayudándonos a estar previstos ante más situaciones dentro del método y mejorar la calidad de código.

    Como pueden ver, en un par de pasos se adquirió de forma sencilla los posibles casos de prueba para este método, evitando cualquier diseño preliminar, cálculo de complejidad ciclomática, o grafo de flujo. Y como dato no menor, ¡la cobertura de código obtenida fue del 100%! 


    Lo ideal sería seguir esto de un análisis del caso ejecutado como para agregar más assertions, pudiendo así validar aspectos más interesantes del negocio y no simplemente verificar que ningún flujo lanza una excepción no controlada.

    De todas maneras, esto no es todo lo que esta herramienta nos puede aportar. Si al hacer clic derecho sobre el método en cuestión, elegimos “Crear IntelliTest”, nos encontramos con que Visual Studio nos genera automáticamente el código para todas esas pruebas unitarias (sin necesidad de “Ejecutar IntelliTest” y luego guardar una por una), incluyéndolas de esta forma dentro de la solución. Además, contamos con privilegios totales de edición sobre dichos métodos de prueba, por lo tanto se pueden expandir, parametrizar y amoldar a las exigencias que surjan. Es así que logramos reducir tiempo de diseño y codificación de las pruebas unitarias, pudiendo invertir más en la construcción del nuevo código a introducir. 

    Test Driven Development con IntelliTest

    Dada la facilidad con la cual se pueden generar los casos de prueba automáticamente, puede ser una buena técnica para desarrollar de una forma similar a como nos sugiere Test Driven Development (TDD), ya que a medida que vamos avanzando sobre la estructura del método, podemos ir probando los flujos con los que contamos. Luego, ir agregando el código necesario para cada salida, y ejecutando IntelliTest a la par de la codificación. 
    Evidentemente, no se trata de TDD íntegramente, dado que no podemos generar los casos iniciales sin tener al menos la firma del método, pero a los efectos, consideramos que es bastante cercana.  

    Veamos este ejemplo donde hay que construir determinado método, para el cual no terminamos todo el código. Es así que, para ejemplificar, tenemos un método sin contenido dentro de cada if, para el cual igualmente ejecutamos IntelliTest.

    Consideremos este código:


    y luego el resultado de ejecutar IntelliTest sobre este método:



    En el análisis de ejecución, no solo vemos las entradas posibles, sino que vemos cómo hay un caso que falla dado que no controlamos que se ingrese un valor nulo. Si corregimos este defecto y ejecutamos IntelliTest nuevamente, podemos ver cómo dicho caso fue solucionado.


    Restricciones de IntelliTest

    En cuanto a restricciones sobre los métodos, la principal que tenemos es que deben ser públicos para toda la solución, por lo tanto no solo el método debe ser public, sino que la clase que lo contiene también debe serlo. Esto se debe a que si queremos que Visual Studio nos genere los métodos de prueba, y teniendo en cuenta que se generan en un paquete aparte del código a probar, esta es la única forma que se tiene de acceder a los mismos.

    A su vez, como sucede cuando queremos construir nosotros mismos una prueba unitaria, es necesario aislar el comportamiento del método, eliminando las referencias a componentes externos, como puede ser transacciones con la base de datos o conexiones de red hacia afuera del módulo donde se está ejecutando.

    Tal vez la mayor desventaja es que solo está disponible con la edición Enterprise de Visual Studio 2015, pero quién sabe, tal vez en el futuro lo encontremos en versiones gratuitas de este IDE.

    IntelliTest y la deuda técnica

    Recuerden que “deuda técnica” se genera al no seguir buenas prácticas de programación, lo cual implica en el futuro tener que realizar un esfuerzo extra para corregir defectos o introducir cambios dado los problemas de mantenibilidad que se encuentran en nuestro código. No siempre tendremos disponible ese tiempo para pagar la deuda, por lo cual podemos abaratar los costos de hacerlo si usamos IntelliTest: identificando qué problemas hay en los métodos codificados, corrigiendo esos defectos, y seguir ejecutando las pruebas hasta bajar la deuda técnica lo más posible.

    Conclusión 

    Incluir las pruebas unitarias dentro de la etapa de desarrollo siempre fue un desafío. Se suele estimar sin considerar este paso, por lo que termina siendo una actividad opcional que se concreta en caso de finalizar la tarea antes de tiempo. Sumado a eso, hoy en día las exigencias por entregar una nueva funcionalidad o una nueva porción de código al cliente son cada vez mayores, por lo cual cada vez más se busca finalizar las tareas de forma que el tiempo utilizado sea el menor posible.

    Para poder solventar este problema, especialmente en equipos que tienen ya cierta deuda técnica, o para los que están enfrentando nuevos desarrollos, hay una muy buena herramienta para obtener ayuda y se llama IntelliTest. 

    IntelliTest es una herramienta eficiente, ágil y simple que nos puede ayudar ampliamente para conocer los distintos flujos que existen en el método a analizar. De todas maneras, estos casos de prueba sólo están basados en el código y no en el negocio, por lo cual está en nosotros el utilizarla como un paso inicial que nos ayude a diseñar, para luego programar las pruebas unitarias que no se generan automáticamente. 


    Reabrir o no Reabrir: esa es la cuestión

    $
    0
    0
    Recientemente publicamos un artículo donde compartimos un posible ciclo de vida de un bug por el que recibimos luego algunas preguntas y comentarios bien interesantes, que queremos aprovechar para intercambiar ideas.

    Entre estos comentarios, nos consultaban por qué el bug no ha pasado a “reabierto”, y que podría cerrase o reabrirse una vez cerrado; todo lo que nos llevó a escribir un nuevo post para analizar la opción “Reabrir” dentro del esquema de la herramienta Mantis.


    En Mantis no hay un estado "reabierto"

    Lo primero para comentarles es que dentro de los estados de la herramienta Mantis no encontraremos un estado “reabierto”, como sí manejan otros gestores de incidentes como Bugzilla o JIRA.

    Por lo tanto, como testers, cuando verifiquemos que no se ha corregido un bug, el flujo a seguir será cambiar el estado a “asignado” (agregando además una nota) para que el desarrollador vuelva a trabajar sobre la incidencia.


    ¿Qué pasará si en lugar de "Cambiar estado" utilizamos la acción “Reabrir”?

    Al momento de instalar Mantis, la configuración por defecto de la herramienta es que al presionar “Reabrir”, el bug reportado cambie a estado “Feedback”, lo que trae consigo algunos inconvenientes para los usuarios. Si utilizáramos esta opción no podríamos distinguir fácilmente aquellos bugs en que el desarrollador está solicitando más información al tester, de otros bugs que están pendientes de resolución. Podrían generarse problemas de comunicación dentro del equipo y además se complicaría la gestión del proyecto ya que los reportes y gráficos de Mantis agruparían los bugs en estado “Feedback” sin discriminar a quién están asignados. Esta transición por defecto, podría ser customizada para todos los proyectos o para un proyecto individual, por un usuario con rol administrador.

    Para ello el Admin tendrá que ingresar a Administración -> Administrar Configuración -> Transición de Estados y ahí indicar que “Reabrir” cambiará el estado del bug reportado a “asignado”.


    Si bien la opción es configurable, les recomendamos tomar precauciones al hacer este cambio.

    Antes de personalizar la opción de “Reabrir” conviene evaluar en qué momento se utilizará esta opción. También analizar cómo afectará “reabrir” un incidente a los reportes y desde luego dar a conocer a todo el equipo cuál será el ciclo de vida del bug a utilizar para así estar todos alineados en la forma de trabajo.

    Hay que tener en cuenta que Mantis no reconocerá si reabrimos incidencias en estado “resuelto” o si en cambio estamos reabriendo bugs “cerrados” hace ya un tiempo atrás, es decir, que la herramienta no sabrá cuándo ha cambiado la versión del sistema.

    Por lo que les recomendamos acompañar el reporte de bugs con etiquetas claras (o campos personalizados) donde se refleje el versionado del sistema bajo pruebas, para no afectar la gestión del proyecto en el que estemos participando.

    Desafío 30 días de testing - Ministry of Testing

    $
    0
    0
    Nos sumamos y difundimos una excelente iniciativa de Rosie Sherry de Ministry of Testing, en la que nos desafían a realizar distintas actividades de testing durante el mes de julio, una por día.


    A lo que en Abstracta le respondimos:


    Imprimimos varias copias y las distribuimos entre los integrantes del equipo que se animaron a participar, armando incluso equipos para competir (sanamente, ¡espero!) y así aumentar más la motivación.

    Entonces, el calendario propuesto y traducido a español sería el siguiente (y con algunos comentarios en cursiva):
    1. Comprar un libro de testing y leerlo para el día 30 (pueden leer el primer libro de testing en español, el cual lo bajan gratis de aquí).
    2. Sacar una foto de algo que están haciendo en el trabajo (lo complicado es que va a ser sábado).
    3. Escuchar un podcast de testing (acá hay muchos: https://testingpodcast.com/).
    4. Compartir un post de testing con alguien que no sea tester.
    5. Leer y comentar un un post de algún blog.
    6. Hacer un test loco.
    7. Encontrar un bug de accesibilidad.
    8. Bajar una app y encontrar 5 bugs, y enviar el feedback al creador.
    9. Crear un mindmap.
    10. Encontrar un evento para asistir (online o cara a cara).
    11. Sacar una foto de tu equipo.
    12. Dibujar / garabatear un problema.
    13. Encontrar un problema de experiencia de usuario.
    14. Salir de tu zona de confort.
    15. Encontrar un problema en un website de e-commerce.
    16. Ir a un evento que no sea de testing (¿sirve salir con los amigos? es fin de semana).
    17. Encontrar y compartir una cita que te inspire.
    18. Encontrar un link roto y reportarlo.
    19. Encontrar y usar una nueva herramienta (tengo varias pendientes por probar).
    20. Encontrar un buen lugar para hacer pruebas de seguridad.
    21. Hacer pruebas de a pares con alguien.
    22. Compartir tu herramienta de testing favorita.
    23. Ayudar a alguien a probar mejor (es lo que intento cada día, pero ese día pondré más foco).
    24. Conectar a algún tester que nunca conectaste antes.
    25. Contribuir a una discusión de testing.
    26. Invitar a alguien que no sea tester a un evento de testers.
    27. Decir algo lindo sobre algo que recién testeaste.
    28. Resumir un bug en 140 caracteres o menos (¡sería feo reportar bugs por Twitter!).
    29. Encontrar un error por uno (leer qué es esto aquí, y la discusión aquí, pero básicamente es un error en las cosas que hay un bucle y este se repite una vez de más o una vez de menos).
    30. Dar feedback positivo a alguien.
    31. Bonus: compartir tu experiencia en el desafío de 30 días en testing en Youtube, Instagram, Twitter o blog. Acá estoy, con esa motivación.
    Acá está toda la info completa. Proponen ir compartiendo el progreso con el hashtag #30daysoftesting. Mañana comenzamos, ¿quién se apunta?

      Review de Gatling para pruebas de performance (escritas en Scala)

      $
      0
      0
      ¿Has oído hablar de Gatling (http://gatling.io/) para pruebas de performance? Parece ser una herramienta nueva (del 2012, bastante nueva) que en este último tiempo ha ganado cierta popularidad (250.000 descargas en estos 4 años, pero más de 60.000 en estos últimos 3 meses, con lo cual, parece que está ganando la atención de la comunidad). Para que no debas dedicar mucho tiempo a ponerte al día con esta herramienta, es que armé este post resumiendo algunas pruebas que hice con la misma, y así en unos minutos ya tengas idea de qué tal está. Además, encontré muy pocas cosas escritas en español sobre el tema.


      Características principales de Gatling

      • Herramienta de pruebas de performance.
      • Gratis y opensource (desarrollada en Java / Scala).
      • El lenguaje de scripting es Scala, con un DSL propio de la herramienta.
      • Funciona con cualquier sistema operativo y cualquier browser.
      • Soporta protocolos HTTP/S, JMS y JDBC.
      • Reportes en HTML muy vistosos.
      • No permite distribuir carga entre distintas máquinas, pero se pueden ejecutar sus pruebas en distintos Cloud de pruebas. Se puede escalar usando https://flood.io/ o Taurus con BlazeMeter, que brinda muchas más facilidades para la integración continua. 
      Con lo cual es una herramienta muy buena cuando:
      • Se necesita ejecutar menos de 600 usuarios concurrentes. Esto es solo un número de referencia, depende de qué tanto procesamiento tenga el script de simulación, pero si se necesita generar más entonces habrá que pagar una herramienta en el Cloud. Un colega me comentó que llegó a ejecutar 4.000 usuarios concurrentes con un script simple desde una sola máquina.
      • Quiero aprender de pruebas de performance (es muy simple para comenzar y el código queda legible).
      • Me interesa mantener el código de pruebas (el lenguaje Scala y el DSL de Gatling están bastante enfocados en facilitar la mantenibilidad de las pruebas, con lo cual es ideal para enfoques de integración continua).
      Esta herramienta permite realizar simulación de carga de usuarios concurrentes contra un sistema, a través de los protocolos HTTP/S, JMS o JDBC. El escenario más típico de uso es el de simular usuarios de un sistema web para poder analizar los cuellos de botella y optimizar el sistema. Para poder comparar, algunas alternativas muy populares en el mercado para esto son JMeter y HP Load Runner (por nombrar una opensource y una comercial, ambas muy populares).

      Gatling es una herramienta gratuita y opensource. Funciona sobre Java, con lo cual está apta para todos los Sistemas Operativos. Es necesario tener la JDK8 (no es suficiente con el runtime, hace falta el kit de desarrollo).

      La herramienta tiene dos ejecutables: uno para grabar las pruebas y otro para ejecutarlas. Las pruebas grabadas quedan en un lenguaje llamado Scala, el cual es muy limpio y fácil de leer incluso si es la primera vez que lo miras. El resultado de la ejecución queda en un reporte HTML muy colorido y bien prolijo. 

      Los scripts cuentan con los aspectos fundamentales para la correcta simulación de usuarios, que a nuestra consideración son:
      • Manejo del protocolo (desde las invocaciones y respuestas, hasta el manejo de headers, cookies, etc).
      • Manejo de strings, facilidades para parsear, expresiones regulares, e incluso, localización de elementos por xpath, json path, css y más. 
      • Validaciones, ya que necesitamos verificar que las respuestas sean correctas. 
      • Parametrización desde distintas fuentes de datos (aquí le veo un punto muy fuerte a la herramienta, ya que brinda varias alternativas y muy fáciles de usar).
      • Manejo de variables dinámicas, conocido como correlación de variables.
      • Manejo de distintos scopes para las variables (a nivel de hilos, prueba, etc.).
      • Modularización (facilitando la mantenibilidad y legibilidad de los scripts).
      • Manejo de esperas (para simular los think times).
      • Gestión de métricas (tiempos de respuesta, tanto individuales como agrupados, transacciones por segundo, cantidad de usuarios concurrentes, errores, cantidad de datos transferidos, etc.).
      • Manejo de errores y excepciones.
      • Control de flujo (loops, if-then-else).
      ¿Qué otra cosa consideras al momento de evaluar el lenguaje de scripting de una herramienta de simulación de carga o estrés?

      En cuanto a los reportes, realmente están vistosos y muy completos, destacando que:
      • Es un HTML con facilidad de navegación, con un índice y ordenado.
      • Muestra gráficamente la información agrupada y muy bien procesada y vinculada.
      • Incluye gráfico de cantidad de usuarios virtuales durante la prueba.
      • Se puede hacer zoom en los gráficos para focalizar y analizar en detalle en determinados puntos.
      • Grafica los requests/second y los responses/second, Incluso comparando con la cantidad de usuarios activos.
      • Se puede ver el detalle para cada “request” como para refinar el análisis.
      • Separa los tiempos de respuesta de las que dieron OK de las que fallaron.
      • Maneja el concepto de percentiles. 
      • Hay un log con los errores obtenidos.
      ¿Qué otra cosa consideras al momento de evaluar los reportes de una herramienta de simulación de carga o estrés?

      En el próximo post les dejo una guía  paso a paso con lo cual llegué a estas conclusiones. 

      Tutorial #1 de Gatling - Instalación y Recorder

      $
      0
      0
      En un post anterior comenté de una herramienta de pruebas de performance y estrés que me llamó la atención y la he estado usando últimamente, incluso como forma de enseñar pruebas de carga en la Universidad. Esta es Gatling y realmente creo que es una muy buena opción para aprender a preparar pruebas de este tipo, así como también para cuando nos importa mantener nuestro código de pruebas limpio y legible, ya que el lenguaje Scala y el DSL de Gatling brindan ventajas muy claras para que los scripts sean mantenibles. Te dejo aquí una serie de pasos como para que puedas probar la herramienta y sacarte las dudas.

      Instalación y ejecución con Gatling

      Se baja de aquí, descomprime y se cuenta con dos ejecutables del tipo bat para Windows, y sh para basados en Unix. El directorio de instalación queda con las siguientes carpetas:

      • /results: Contiene los resultados en formato HTML.
      • /bin: Contiene los ejecutables de Gatling.
      • /target: Contiene los archivos de la compilación de los escenarios.
      • /conf: Archivos de configuración. 
      • /user-files: Acá estarán nuestros archivos, los scripts y archivos de datos.
      • /lib: Archivos jar de Gatling.

      Recorder de Gatling

      Al ejecutar gatling/bin/recorder.bat se abre una ventana como la siguiente, que nos permite configurar las opciones de grabación.



      Algo que me resulta curioso es que en el sitio de Gatling ponen como ventaja que el Recorder sirve para varios navegadores, pero en realidad es una aplicación que funciona separada de los navegadores, con lo cual, hace falta configurar el browser para derivar los requests hacia el recorder (sí, igual que con JMeter). O sea, sí es cierto que funciona con cualquier navegador, pero en realidad funciona con cualquier elemento que envíe peticiones HTTP que se le pueda configurar manualmente el proxy.

      Aspectos destacables del recorder


      • Podemos grabar con el recorder, funcionando este como un proxy (tal como lo hacen todas las herramientas de grabación de pruebas de performance), y podemos también generar un script a partir de un archivo HAR, lo cual es una sesión grabada con alguna herramienta como Fiddler o CharlesProxy. Esto se puede seleccionar en el combo marcado en el cuadro rojo número 1. 
      • Al igual que las últimas versiones de JMeter, se puede trabajar con “follow redirect” (recuadro número 3) y “infer html resources” (recuadro número 4) de forma automática. Esto reduce la cantidad de líneas en el script y facilita la mantenibilidad, haciendo la prueba más real y menos costosa. El problema que trae aparejado es que necesita más procesamiento de la máquina generadora de carga, ya que debe realizar mucho más procesamiento. 
      • Se pueden agregar automáticamente verificaciones de las respuestas obtenidas (recuadro número 5). O sea, al momento de la grabación se guardan las respuestas en archivos TXT y en el script se agrega una validación que compara byte a byte la respuesta obtenida de las peticiones correspondientes con las que se obtuvieron en la grabación y se guardaron. Esto no es muy útil para sistemas dinámicos, sí para páginas estáticas, aunque imagino que debe agregar una sobrecarga en las máquinas generadoras de carga. 

      Follow redirect: se manejan los mensajes con código de respuesta 3XX automáticamente, tal como lo hace el browser. O sea, si la respuesta es 302 – Moved temporarly, la respuesta tiene un header llamado “location” que indica la URL a donde hay que ir a buscar el recurso solicitado, y si la opción “follow redirect” está habilitada el mismo motor de ejecución de la herramienta hará el pedido correspondiente en forma adecuada. Si esto no está habilitado, entonces sería necesario tener otra invocación en el script, y muchas veces es necesario correlacionar variables en caso que esa URL maneje parámetros.

      Infer html resources: también en forma automática, se analiza el HTML de una respuesta, se buscan los recursos embebidos (como ser imágenes, archivos CSS o JavaScript) y se invocan las peticiones correspondientes. Si esto no está habilitado, entonces estos pedidos deberían estar explícitos en el script. Esto lo he visto muy útil por ejemplo si tenemos un test case en el que se compra un producto en un sitio de e-commerce, primero se busca el producto, y en ese script parametrizamos la palabra clave de búsqueda; en este caso el resultado de cada búsqueda traerá una lista de productos diferentes, entonces las imágenes que se soliciten en cada caso serán diferentes (si se busca “macbook” traerá imágenes de computadoras Mac, y si se busca “cellphone” traerá imágenes de distintos celulares). Entonces, el hecho que los recursos embebidos se pidan en forma automática realmente simplifica y mejora la veracidad de la prueba.

      Una vez que todo está configurado, se presiona START (en la imagen, recuadro número 6). Esto significa que hay un socket en el puerto 8000 (o el que se configure en el input del recuadro número 2 de la imagen) escuchando para funcionar como proxy. Para poder capturar las peticiones que realiza el browser, es necesario configurar el proxy del browser a localhost en el puerto 8000 (o el puerto que se haya configurado en el Recorder de Gatling).

      Yo lo que suelo hacer para facilitar el cambio entre grabar y no grabar, es instalar alguna extensión del browser para manejar las configuraciones de proxy. En el caso de Chrome, que es el navegador que suelo utilizar actualmente, utilizo SwitchySharp. Entonces, configuro una vez sola y luego con un solo clic paso de grabar a conexión sin proxy y viceversa.

      TL;DR

      Entonces, por lo general lo único que hay que hacer es abrir el Recorder, poner el nombre con el que grabar el script, presionar Start, y configurar el browser para que utilice ese proxy, y ejecutar los pasos del caso de prueba.

      Ejemplo de grabación con Gatling

      Me definí el siguiente ejemplo para grabar la prueba:

      1. Acceder a opencart.abstracta.us.
      2. Introducir el texto “macbook” en el campo de búsqueda y presionar el botón de búsqueda.
      3. Acceder al primer producto que aparece en la lista para ver sus detalles.

      Mientras uno va grabando tiene la posibilidad de ir insertando comentarios. Acá a mí lo que me resulta útil es ir identificando qué paso de mi caso de prueba voy ejecutando, algo descriptivo en lenguaje natural, para que luego sea más fácil identificar lo que hace el script en cada línea. En la siguiente imagen se puede ver un ejemplo grabando sobre un sitio de prueba, se puede ver cómo el Recorder va mostrando todos los requests que va capturando, y un TAG que agregué al que le puse “Paso 2 – realizar búsqueda”.


      Al finalizar todos los pasos del script uno presiona el botón “Stop & Save” y se genera el script en la carpeta indicada.

      La semana que viene continúo con el tutorial, viendo cómo editar el script guardado, incluso algunas recomendaciones para armar un buen entorno de trabajo.


      Otras referencias a Gatling en Español (lo que encontré hasta hoy)

      • https://juliomunoz.wordpress.com/2014/11/13/probando-gatling/
      • http://emerrefe.github.io/qa-blog/Gatling-tool-pruebas-de-stress/
      • Algunos ejemplos https://github.com/Senescyt/pruebas-rendimiento
      • http://nbortolotti.blogspot.com.uy/2015/06/una-prueba-de-estres-para-mi-aplicacion.html


      Tutorial #2 de Gatling - Scripting en Scala

      $
      0
      0
      Luego de mostrarte un resumen de Gatling para pruebas de performance (carga y estrés) y del primer tutorial que mostraba cómo instalar y cómo grabar un script, vamos a ver ahora qué hay dentro de un script, que tiene la particularidad de ser un texto plano en lenguaje Scala. Antes de pasar al script, veamos un par de cosas previas.

      ¿Por dónde comenzar con Scala?

      Si bien nunca había visto nada en este lenguaje, me resultó fácil de leer y entender. Para conocer más del lenguaje se puede estudiar acá http://www.scala-lang.org/, pero desde mi punto de vista no hace falta, es suficiente con mirar la especificación y ejemplos que hay en el sitio de Gatling, porque al final no se trata solo del lenguaje en sí, sino de las funcionalidades que ofrece el framework, o sea, el DSL de Gatling (el lenguaje específico de la herramienta).

      El script que se muestra en la documentación introductoria me resultó muy útil para entender mejor el funcionamiento, con lo cual te recomiendo que comiences por ahí. En este se explican los elementos claves del lenguaje y las funcionalidades brindadas, en particular es importante entender los conceptos de simulations, scenarios, feeders, loops y algunos más que iremos revisando.

      Ambiente de desarrollo

      Para trabajar con el texto siempre es muy útil tener un buen editor, que ayude a autocompletar, o al menos a colorear las cosas de acuerdo a la especificación del lenguaje. Aquí tenemos varias opciones. Al comienzo utilicé un editor de texto, pero me llevaba bastante trabajo darme cuenta de los errores de compilación que cometía y asiste muy poco al trabajo de escribir código. Como soy fiel usuario de Notepad++, comencé con este editor agregándole la definición del lenguaje que la descargué de aquí.

      Finalmente lo que hice, y que me está resultando mucho más productivo, fue instalar un plugin de Eclipse para desarrollar en Scala, y creé un proyecto para el test al cual le tuve que agregar todas las bibliotecas que vienen con la herramienta.

      En esta página mencionan algunos editores de Scala, y en particular comentan que hay plugins no solo para Eclipse, sino que también para IntelliJ IDEA y NetBeans. El que estoy usando se descarga de aquí.

      El script recién grabado con el recorder de Gatling

      El script recién grabado con algún ajuste menor, abierto con el editor de Notepad++ con el lenguaje definido se ve como muestra la imagen:



      Por las dudas, el guión de prueba que me había definido era este:

      • Acceder a opencart.abstracta.us.
      • Introducir el texto “macbook” en el campo de búsqueda y presionar el botón de búsqueda.
      • Acceder al primer producto que aparece en la lista para ver sus detalles.


      Prestemos atención a un par de cosas del script:

      • Como indiqué antes, es posible agregar comentarios durante la grabación que quedan en el código. Me parece muy importante aprovechar esto para que el script quede fácil de entender. Se puede ver un comentario en verde que dice "Paso 1 - acceder a opencart" por ejemplo.
      • El Recorder graba los think-times. O sea, si hice una pausa entre una página y otra, agregará al script una espera explícita. Esto está muy bien, ya que para simular un usuario real no queremos que ejecute un request enseguida del otro, pero recomiendo revisar el script por si quedó alguna pausa muy exagerada o no muy de acuerdo al comportamiento normal de los usuarios. 
      • El script quedó bien corto y simple gracias al uso de “infer html resources” tal como lo expliqué en el post anterior. Si no fuese por esto aparecería un request más por cada imagen, archivo CSS, JavaScript, etc., que se utiliza en cada página. 
      • Parte de las modificaciones que le hice al script grabado fue modificar las líneas “.exec(http("request_0")”, donde “request_0” identifica al paso. Conviene renombrar los “request_X” a algo más legible ya que estos forman parte de los informes. Se puede ver esto reflejado en la siguiente imagen. El reporte podría ser mucho más legible si en lugar de “request_0” dijera “Paso1_Home” o lo que corresponda. Esto lo veremos en más detalle luego, al hablar de reportes.

      Organización de un script: apostando a la mantenibilidad

      Si bien todos sabemos que los scripts a nivel de protocolo son casi imposibles de mantener y a cada poco tenemos que rehacerlos casi de cero, Gatling presenta un enfoque bien interesante que quizá permita apuntar a mantener los scripts y no tirarlos a la basura luego de la ejecución de un ciclo de pruebas. 

      Además, casi que el slogan de Gatling es que debemos considerar el código de pruebas de performance como código de producción. Esto es algo que con herramientas como JMeter se vuelve muy difícil de realizar. 

      La herramienta maneja un concepto muy interesante, similar a Page Object para Selenium o cualquier enfoque de testing funcional automatizado. Aquí está muy bien explicado. En la siguiente imagen se pueden ver los cambios realizados para seguir este patrón de diseño:


      De esta forma la definición del escenario queda más legible y más fácil de modificar. Por otra parte, si algo cambiase, al tener esta modularización podríamos ajustar solo la página que cambió, y de esa forma todos nuestros scripts y escenarios quedarían actualizados con la menor cantidad de cambios posible. El cambio del código del script no afecta para nada en la forma en que se muestran los resultados, es solo un aspecto de calidad de código y facilidad de mantenimiento. 

      Una buena estrategia para esto es tener archivos separados por cada una de las páginas que están consideradas en las pruebas, en las cuales se definan esos objetos. Cada objeto tendrá las distintas acciones que se pueden desencadenar desde esas páginas. De este modo podría ser bien simple localizar los métodos afectados al estar coordinados con el equipo de desarrollo. Incluso más: cada historia podría tener dentro de su DoD (definition of done) que se haga un simple test, el cual podría ser luego incluido en una prueba mayor.

      Configuración de Escenarios de Carga

      Si bien esto es de lo último que uno configura en un script, prefiero verlo ahora ya que seguiremos ejemplificando con ejecuciones, entonces es necesario tener claro cómo se entiende la definición de lo que se ejecuta, o sea, la cantidad de usuarios concurrentes, durante cuánto tiempo, en qué forma ingresan los usuarios, etc.

      Se pueden definir los escenarios como una secuencia de pasos, y en esos pasos definir los requests. Se pueden definir entonces diferentes escenarios de esa forma:

      val users = scenario("Users").exec(Search.search, Browse.browse)
      val admins = scenario("Admins").exec(Search.search, Browse.browse, Edit.edit)

      Estos escenarios se pueden luego ejecutar con determinado ramp-up (para que no ingresen el total de usuarios de una, sino que accedan progresivamente durante cierto tiempo).

      setUp(
        users.inject(rampUsers(10) over (10 seconds)),
        admins.inject(rampUsers(2) over (10 seconds))
      ).protocols(httpConf)

      Se puede definir el escenario en transacciones por segundo:

      scn.inject(rampUsers(500) over (10 minutes)).throttle(reachRps(100) in (10 seconds), holdFor(10 minutes))

      Veamos ahora más detalles relacionados a cómo armar adecuadamente la simulación de un usuario virtual, o sea, preparar un script que simule las acciones que realizaría un usuario real de la manera más fiel posible. 

      Validaciones / Assertions

      Uno de los aspectos fundamentales de todo caso de prueba es que se pueda validar la respuesta, y evitar falsos negativos, esto es, que quizá estamos obteniendo tiempos excelentes y es porque la aplicación está respondiendo “bad request” en lugar de procesar el pedido que estamos realizando. Es necesario tener mecanismos que nos permitan verificar las respuestas, no al mismo detalle que lo haríamos en una prueba automatizada funcional, pero al menos buscar textos en el body de la respuesta o en los headers. Para ver cómo hacer buenas validaciones recomiendo este post de Leticia Almeida, que si bien está enfocado en JMeter, aplica a cualquier herramienta para pruebas de performance. 

      Para las validaciones Gatling provee del elemento “check”. La documentación al respecto está aquí. Algunos ejemplos aplicados al script que estuve armando:


      En este ejemplo se verifica que el código de respuesta del paso 1 (pantalla inicial) sea 200, que no aparezca la palabra “Error” y que aparezca algún link (los ejemplos fueron un poco arbitrarios, pero con la finalidad de mostrar distintos aspectos que se pueden validar).

      Algo interesante a saber, si no se agregan validaciones de forma explícita, se realiza una validación automática que verifica que el código de respuesta es 2XX o 304 (no entendía por qué un 304 estaría bien, y no lo estaría un 302 o 303, pero revisando el RFC de HTTP vi que el 304 es específicamente para los elementos que no han sido modificados, que se hace una petición condicional, lo cual entiendo que es especialmente útil para recursos como archivos CSS, JavaScript o imágenes). 

      Otro aspecto importante, si un chequeo falla en un request, entonces no se realizan los pedidos secundarios, o sea, no se piden los recursos embebidos en esa página, ya que directamente se corta el script.

      Las validaciones de la imagen están aplicadas a un solo request. Un concepto bien interesante que maneja Gatling son las validaciones globales (documentación completa aquí). 

      assertThat(
                global.responseTime.max.lessThan(5550)
                global.successfulRequest.percent.greaterThan(95)
      )

      setUp(...).assertions(
        global.responseTime.max.lessThan(50),
        global.successfulRequests.percent.greaterThan(95)
      )

      De esta forma estaríamos definiendo criterios de aceptación globales a la prueba. También se pueden definir distintos criterios de esta forma:

      setUp(...).assertions(
        details(requestName).requestsPerSec.greaterThan(60),  
        details(requestName).responseTime.percentile3.lessThan(5000),
        details(requestName).failedRequests.percent.lessThan(1),  
        details(requestName).failedRequests.percent.lessThan(1)
      )  

      Control de fallas

      Asociado a las validaciones tenemos al control de fallas y excepciones, o sea, controlar qué hacer cuando se encuentra un error. Por ejemplo, se puede reintentar varias veces, cortar la ejecución de un bloque entero, etc. 

      Podemos definir que cierto bloque de código se intente varias veces en caso que haya una falla con tryMax. Para ejemplificar cómo funciona esto, agregamos una validación que falle a uno de los pasos, así luego al ejecutar podemos observar que se haya reintentado. Esto se logra como muestra la siguiente figura:


      Y en el resultado de la ejecución podemos ver que como el string “Search” se encuentra en la respuesta, con lo cual el script falla (observar el "notExists"), entonces intentó ejecutar dos veces. Esto se puede observar en el recuadro rojo:


      Por otra parte, podríamos definir que, si hay un fallo en algún paso, directamente se corte toda la ejecución de un bloque. Para esto modificamos el script como se muestra a continuación, tenemos dos sub-pasos para el paso 3 con una validación como para que falle a propósito, y un bloque que los combina con el método exitBlockOnFail

      Definimos dos escenarios, uno para que ejecute la página de inicio, los dos pasos por separado, y luego un escenario que ejecuta la página de inicio y el bloque. Así veremos la diferencia que plantea usar el bloque.


      El resultado de ejecución del escenario “scn” muestra que se ejecutan los 3 pasos:


      Sin embargo, al ejecutar “scn2” que considera ejecutar el bloque, ejecutó los primeros dos pasos, y el tercero no, ya que al fallar algo del bloque lo cortó:


      Al margen, pero de todos modos importante, es que en este ejemplo comenté la línea “.inferHtmlResources()”, así de esa forma el debug se hace más rápido, ya que no se invocan los pedidos secundarios. Esto es ideal para toda la etapa de automatización, pero no hay que olvidarse de descomentarlo al finalizar, antes de ejecutar las pruebas. 

      Manejo de cookies, cache y otros aspectos de HTTP

      Tal como lo cuenta la documentación, Gatling no es un browser, o sea, no ejecuta JavaScript ni aplica estilos CSS, trabaja a nivel de protocolo. Algo fundamental en toda herramienta que trabaja a nivel de HTTP es el manejo de cookies. En el caso de Gatling las cookies se manejan en forma transparente y automática, tal como lo haría el browser. Nunca entendí por qué en JMeter es necesario agregar un elemento específico para eso, cuando en todos los casos vamos a necesitar que se haga una gestión adecuada de cookies. 

      De todos modos, para los casos en que haga falta agregar cookies de forma explícita, se cuenta con algunas funcionalidades para este fin que están documentadas aquí

      Por otra parte, otro aspecto que me gusta muchísimo de Gatling, es que maneja el caché tal como lo hace un browser, considerando los headers que indican el tiempo de expiración y última modificación. Esto se puede deshabilitar, pero por defecto lo hace. Más información aquí.

      En esta misma página se puede ver que hay muchos aspectos más de HTTP que son tenidos en cuenta, y otro fundamental es la autenticación, especialmente necesario para aquellos sitios que lo realizan por LDAP o Active Directory. 

      También se codifican los requests en forma automática. Imaginemos que tenemos un request parametrizado donde se le pasa el nombre del producto, ¿qué pasa si buscamos un producto que tiene un espacio o algún carácter no permitido en una URL? La respuesta es que se deben encodear. No nos tenemos que preocupar por esto ya que Gatling lo hace automáticamente. 

      Control de flujo

      Muchas veces resulta necesario manejar el flujo de control de ejecución de un script, ya sea agregando condicionales if-then-else como agregando bucles tipo loop. Todas estas cosas están contempladas, copio aquí los dos ejemplos que considero más básicos y necesarios para esto, tomados de la documentación.

      object Browse {
        val browse = repeat(5, "n") { // 1
          exec(http("Page ${n}")
            .get("/computers?p=${n}")) // 2
            .pause(1)
        }
      }

      doIf("${myBoolean}") {
        // executed if the session value stored in "myBoolean" is true
        exec(http("...").get("..."))
      }

      Parametrización 

      Si quiero simular 500 usuarios accediendo al sitio de e-commerce, cada uno buscando un producto y mirándolo, no puedo hacerlo siempre con el mismo producto, ya que esto ocasionaría ciertos comportamientos que no simularían fielmente la realidad:
      • El servidor tendría los cachés a favor, tanto los que están a nivel web como en la base de datos.
      • Se podrían generar bloqueos que no son reales, todos los usuarios queriendo acceder al mismo registro (a menos que el dueño del sitio de e-commerce solo venda aspirinas).
      Por este motivo es que siempre es necesario analizar qué datos hay que variar para que la prueba sea real. Una vez definidos los datos a variar, es necesario parametrizar el script. En particular Gatling usa el concepto de“Feeders” para parametrizar los tests. 

      Hay muchos tipos de feeders, para consumir datos de diversas fuentes (bases de datos, archivos, etc.), pero el más común considero que es el archivo CSV (archivo de texto plano separado por comas).
      Para nuestro ejemplo de buscar productos en OpenCart, podríamos definir un archivo llamado “products.csv” en la carpeta “data” dentro del directorio de Gatling, con el siguiente contenido:

      product
      Macbook
      Desktop
      Camera
      Tablets

      La primera fila se considera el nombre de la variable (es muy útil cuando tenemos varias columnas, separadas por coma), y el resto de las filas son los datos que se usarán para esa variable.

      En el código debemos definir de esta manera:

      val feeder = csv("products.csv").random

      En este caso estamos indicando que se tomen los datos en orden aleatorio, pero hay diferentes formas de tomarlos (secuencial, diferentes órdenes, etc.). Luego las variables se usan similar a como se usan en JMeter, en todos los lugares donde decía “macbook” sustituimos por“${product}”.


      Así logramos que en cada ejecución se utilice un valor diferente en esa variable, lo que equivale a que cada usuario que simulamos hará una búsqueda diferente. 

      Es importante no olvidarse de agregar la invocación a “feed” para que se carguen las variables:

      val scn3 = scenario("opencart").feed(feeder).exec(Search.searchProduct)

      Más información sobre feeders acá.

      Correlación de variables

      Para trabajar con sitios dinámicos es fundamental manejar variables de forma correlacionada, esto es, tomar datos de las respuestas que luego son enviados en los siguientes requests. Esto es algo que por lo general es muy transparente para el usuario pues lo resuelve el browser sin que nos demos cuenta. 

      Siguiendo el ejemplo, cuando buscamos un producto y hacemos clic en el primero, podemos ver que en la URL de la invocación del paso 3 hay un parámetro que es product_id y se envió con el valor 43, el cual corresponde a la Macbook que aparecía como primer resultado de búsqueda. Como parametrizamos la búsqueda, cada usuario obtendrá distintos resultados, y lo que corresponde es que en el paso tres se intente visualizar el primer producto que aparece en la respuesta de la búsqueda.

      Es necesario entonces poder obtener el product_id correspondiente, para lo cual utilizaremos nuevamente los “check” pero esta vez con una funcionalidad extra que nos permite almacenar lo que obtenemos de una expresión regular en una variable. Se puede observar en la siguiente figura el código subrayado en rojo:


      Ahí se puede ver que se extrae el identificador del producto buscádolo en la respuesta con una expresión regular. Esto lo carga en una variable que es utilizada luego (en los recuadros rojos).
      Pueden encontrar más información de este mecanismo aquí.

      Lo novedoso es que se pueden buscar valores con distintos mecanismos, no solo por expresiones regulares, también se pueden usar CSS Selectors y XPaths tal como en Selenium. Para esto hay diversas herramientas que nos ayudan a encontrar el XPath o CSS selector para localizar elementos en una página; incluso el “inspeccionar elemento” en el browser cuenta con la posibilidad de extraerlos tal como muestra la siguiente imagen:


      Cierre

      Con esto vimos lo que me parece más importante como para comenzar a preparar scripts en Gatling. En el próximo post nos centraremos en la ejecución y reportes de la herramienta que es uno de los aspectos destacables. 



      Viewing all 48 articles
      Browse latest View live