Control de flujo bucles

Bucles while, times y forEach

Los bucles en Selenium IDE permiten repetir secuencias de comandos de forma automática, lo que resulta especialmente útil cuando necesitamos procesar múltiples elementos similares o repetir acciones un número específico de veces. Selenium IDE ofrece tres tipos principales de bucles: times, while y forEach, cada uno diseñado para diferentes escenarios de testing.

Bucle times

El comando times es el más simple de usar cuando conocemos exactamente cuántas veces queremos repetir una secuencia de acciones. Su sintaxis es directa: especificamos el número de repeticiones en el campo Target y cerramos el bucle con end.

Command: times
Target: 3
Value: (vacío)

... comandos a repetir ...

Command: end
Target: (vacío)
Value: (vacío)

Un ejemplo práctico sería hacer clic en un botón "Siguiente" tres veces para navegar por páginas de resultados:

Command: times
Target: 3
Value: 

Command: click
Target: css=button[id="next-page"]
Value: 

Command: waitForElementVisible
Target: css=.page-content
Value: 3000

Command: end
Target: 
Value: 

Este bucle es ideal para casos de testing donde necesitamos repetir una acción un número fijo de veces, como rellenar múltiples formularios idénticos o navegar por un número conocido de páginas.

Bucle while

El comando while ejecuta repetidamente un conjunto de comandos mientras se cumpla una condición específica. Es más flexible que times porque la repetición depende del estado actual de la página, no de un número fijo.

Command: while
Target: ${condición}
Value: (vacío)

... comandos a repetir ...

Command: end
Target: (vacío)
Value: (vacío)

Para usar while efectivamente, necesitamos establecer una variable de control que cambie durante la ejecución del bucle. Por ejemplo, podemos contar elementos visibles y continuar mientras existan:

Command: storeElementCount
Target: css=.item-list li
Value: itemCount

Command: while
Target: ${itemCount} > 0
Value: 

Command: click
Target: css=.item-list li:first-child .delete-button
Value: 

Command: waitForElementNotVisible
Target: css=.loading-spinner
Value: 

Command: storeElementCount
Target: css=.item-list li
Value: itemCount

Command: end
Target: 
Value: 

Este ejemplo elimina elementos de una lista uno por uno hasta que no queden elementos. Es crucial actualizar la variable de control dentro del bucle para evitar bucles infinitos.

Bucle forEach

El comando forEach está diseñado específicamente para procesar colecciones de elementos de la página. Automáticamente itera sobre cada elemento encontrado por un localizador, almacenando cada elemento en una variable que podemos usar dentro del bucle.

Command: forEach
Target: css=.product-card
Value: product

... comandos que usan ${product} ...

Command: end
Target: (vacío)
Value: (vacío)

Un caso práctico sería validar información en cada tarjeta de producto de una página de catálogo:

Command: forEach
Target: css=.product-card
Value: productCard

Command: storeText
Target: ${productCard} .product-name
Value: productName

Command: storeText
Target: ${productCard} .product-price
Value: productPrice

Command: echo
Target: Producto: ${productName}, Precio: ${productPrice}
Value: 

Command: verifyElementPresent
Target: ${productCard} .add-to-cart-button
Value: 

Command: end
Target: 
Value: 

En este ejemplo, forEach recorre cada elemento con clase product-card, almacenando la referencia en la variable productCard. Luego podemos usar ${productCard} como base para localizar elementos específicos dentro de cada tarjeta.

Consideraciones importantes

Al trabajar con bucles en Selenium IDE, debemos tener presentes algunas buenas prácticas:

• Evitar bucles infinitos: Siempre asegurar que existe una condición de salida clara, especialmente en bucles while
• Usar esperas apropiadas: Incluir comandos waitFor dentro de los bucles para manejar elementos que aparecen dinámicamente
• Validar antes de actuar: Verificar que los elementos existen antes de interactuar con ellos, especialmente en bucles forEach
• Mantener simplicidad: Evitar anidar bucles dentro de otros bucles para mantener la legibilidad y el mantenimiento

Los bucles transforman nuestros tests de secuencias lineales simples a herramientas más inteligentes capaces de adaptarse a contenido dinámico y procesar múltiples elementos de forma eficiente.

Repetición de acciones en tests

La repetición de acciones en testing automatizado va más allá de la simple iteración; se trata de crear tests robustos que puedan manejar escenarios complejos del mundo real donde los datos y elementos cambian dinámicamente. Los bucles nos permiten abordar situaciones que serían impracticables con comandos lineales.

Casos comunes de repetición en testing

Validación de listas dinámicas es uno de los escenarios más frecuentes. Imagina una página de resultados de búsqueda donde necesitamos verificar que todos los elementos contienen cierta información:

Command: storeElementCount
Target: css=.search-result
Value: totalResults

Command: times
Target: ${totalResults}
Value: 

Command: storeEval
Target: ${index} || 1
Value: currentIndex

Command: verifyElementPresent
Target: css=.search-result:nth-child(${currentIndex}) .product-image
Value: 

Command: verifyElementPresent
Target: css=.search-result:nth-child(${currentIndex}) .product-title
Value: 

Command: storeEval
Target: ${currentIndex} + 1
Value: index

Command: end
Target: 
Value: 

Procesamiento de formularios múltiples es otro caso típico. En aplicaciones empresariales, frecuentemente encontramos páginas con varios formularios idénticos que requieren validación:

Command: forEach
Target: css=.form-container
Value: formElement

Command: click
Target: ${formElement} input[name="name"]
Value: 

Command: type
Target: ${formElement} input[name="name"]
Value: Usuario Test

Command: click
Target: ${formElement} input[name="email"]
Value: 

Command: type
Target: ${formElement} input[name="email"]
Value: test@empresa.com

Command: click
Target: ${formElement} button[type="submit"]
Value: 

Command: waitForElementVisible
Target: ${formElement} .success-message
Value: 5000

Command: end
Target: 
Value: 

Manejo de paginación automática

La navegación por páginas es un escenario donde los bucles while brillan especialmente. Podemos automatizar la navegación completa por resultados paginados:

Command: store
Target: true
Value: hasNextPage

Command: while
Target: ${hasNextPage} == "true"
Value: 

Command: storeElementCount
Target: css=.result-item
Value: itemsOnPage

Command: echo
Target: Procesando ${itemsOnPage} elementos en esta página
Value: 

Command: forEach
Target: css=.result-item
Value: item

Command: storeText
Target: ${item} .item-title
Value: itemTitle

Command: verifyText
Target: ${item} .item-title
Value: *
Pattern: *

Command: end
Target: 
Value: 

Command: storeElementCount
Target: css=button.next-page:not([disabled])
Value: nextButtonEnabled

Command: if
Target: ${nextButtonEnabled} > 0
Value: 

Command: click
Target: css=button.next-page
Value: 

Command: waitForElementVisible
Target: css=.result-item:first-child
Value: 10000

Command: else
Target: 
Value: 

Command: store
Target: false
Value: hasNextPage

Command: end
Target: 
Value: 

Command: end
Target: 
Value: 

Validación de datos en tablas

Testing de tablas es un área donde la repetición de acciones resulta especialmente valiosa. Podemos validar cada fila de una tabla asegurándonos de que contiene los datos esperados:

Command: storeElementCount
Target: css=table tbody tr
Value: totalRows

Command: store
Target: 1
Value: rowIndex

Command: while
Target: ${rowIndex} <= ${totalRows}
Value: 

Command: storeText
Target: css=table tbody tr:nth-child(${rowIndex}) td:nth-child(1)
Value: columnOne

Command: storeText
Target: css=table tbody tr:nth-child(${rowIndex}) td:nth-child(2)
Value: columnTwo

Command: verifyNotText
Target: css=table tbody tr:nth-child(${rowIndex}) td:nth-child(1)
Value: 

Command: verifyNotText
Target: css=table tbody tr:nth-child(${rowIndex}) td:nth-child(2)
Value: 

Command: storeEval
Target: ${rowIndex} + 1
Value: rowIndex

Command: end
Target: 
Value: 

Estrategias para tests robustos

Combinación de bucles con condicionales crea tests más inteligentes que pueden adaptarse a diferentes estados de la aplicación:

Command: storeElementCount
Target: css=.notification-item
Value: notificationCount

Command: if
Target: ${notificationCount} > 0
Value: 

Command: forEach
Target: css=.notification-item
Value: notification

Command: storeAttribute
Target: ${notification}@class
Value: notificationClass

Command: if
Target: "${notificationClass}".includes("error")
Value: 

Command: click
Target: ${notification} .dismiss-button
Value: 

Command: waitForElementNotVisible
Target: ${notification}
Value: 3000

Command: end
Target: 
Value: 

Command: end
Target: 
Value: 

Command: end
Target: 
Value: 

Manejo de errores durante repeticiones es crucial para mantener la estabilidad de nuestros tests. Podemos usar comandos verify en lugar de assert dentro de bucles para que los errores individuales no detengan todo el proceso:

Command: forEach
Target: css=.data-card
Value: card

Command: verifyElementPresent
Target: ${card} .card-header
Value: 

Command: verifyElementPresent
Target: ${card} .card-content
Value: 

Command: storeElementCount
Target: ${card} .error-indicator
Value: errorCount

Command: if
Target: ${errorCount} > 0
Value: 

Command: echo
Target: ADVERTENCIA: Error encontrado en tarjeta
Value: 

Command: storeText
Target: ${card} .error-message
Value: errorMessage

Command: echo
Target: Error: ${errorMessage}
Value: 

Command: end
Target: 
Value: 

Command: end
Target: 
Value: 

La repetición de acciones convierte nuestros tests en herramientas verdaderamente automatizadas capaces de procesar cantidades variables de datos y adaptarse a diferentes estados de la aplicación, proporcionando una cobertura de testing más completa y realista.