Control de flujo condicional

Comandos if, else if, else

Los comandos condicionales en Selenium IDE permiten que nuestros tests tomen decisiones automáticas basándose en el estado actual de la página web. Esto resulta especialmente útil cuando trabajamos con aplicaciones que pueden mostrar diferentes elementos según el contexto o el usuario.

La lógica condicional funciona evaluando una expresión y ejecutando diferentes bloques de comandos según el resultado. Selenium IDE utiliza una sintaxis simple y estructurada que no requiere conocimientos avanzados de programación.

Estructura básica de los condicionales

El comando if es el punto de entrada de cualquier estructura condicional. Su sintaxis básica requiere tres elementos fundamentales:

• Command: if
• Target: La condición a evaluar
• Value: Se deja vacío

Command: if
Target: ${elementPresent}
Value: (vacío)

Todos los bloques condicionales deben cerrarse obligatoriamente con el comando end. Este comando marca el final del bloque condicional y es esencial para que Selenium IDE interprete correctamente la estructura.

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

Comando if básico

El comando if evalúa una condición y ejecuta los comandos siguientes solo si la condición es verdadera. Las condiciones más comunes incluyen:

Verificar si un elemento está presente:

Command: if
Target: ${elementPresent}
Value: (vacío)

Command: click
Target: css=.modal-close
Value: (vacío)

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

Verificar el contenido de una variable:

Command: storeText
Target: id=user-status
Value: userStatus

Command: if
Target: ${userStatus} == "logged in"
Value: (vacío)

Command: click
Target: id=dashboard-link
Value: (vacío)

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

Comando else

El comando else proporciona una alternativa cuando la condición del if no se cumple. Se coloca después de todos los comandos del bloque if y antes del end.

Command: if
Target: ${buttonVisible}
Value: (vacío)

Command: click
Target: id=primary-button
Value: (vacío)

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

Command: click
Target: id=alternative-button
Value: (vacío)

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

Este ejemplo muestra un flujo alternativo típico: si el botón principal está visible, hacer clic en él; de lo contrario, usar el botón alternativo.

Comando else if

El comando else if permite evaluar múltiples condiciones de forma secuencial. Es útil cuando tenemos más de dos posibles escenarios en nuestro test.

Command: storeText
Target: css=.user-role
Value: userRole

Command: if
Target: ${userRole} == "admin"
Value: (vacío)

Command: click
Target: id=admin-panel
Value: (vacío)

Command: else if
Target: ${userRole} == "editor"
Value: (vacío)

Command: click
Target: id=content-editor
Value: (vacío)

Command: else if
Target: ${userRole} == "viewer"
Value: (vacío)

Command: click
Target: id=read-only-dashboard
Value: (vacío)

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

Command: click
Target: id=login-page
Value: (vacío)

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

Expresiones condicionales comunes

Las expresiones más utilizadas en Selenium IDE para condiciones incluyen:

• Comparación de igualdad: ${variable} == "valor"
• Comparación de diferencia: ${variable} != "valor"
• Verificación de presencia de elemento: ${elementPresent}
• Verificación de visibilidad: ${elementVisible}

Para usar estas expresiones, necesitamos preparar las variables previamente:

Command: storeElementPresent
Target: id=notification-banner
Value: bannerExists

Command: if
Target: ${bannerExists}
Value: (vacío)

Command: click
Target: css=.banner-close
Value: (vacío)

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

Ejemplo práctico: Manejo de modal opcional

Un caso real donde los condicionales son especialmente útiles es el manejo de ventanas modales que pueden aparecer o no:

Command: click
Target: id=submit-form
Value: (vacío)

Command: pause
Target: 1000
Value: (vacío)

Command: storeElementPresent
Target: css=.confirmation-modal
Value: modalPresent

Command: if
Target: ${modalPresent}
Value: (vacío)

Command: click
Target: css=.modal-confirm-button
Value: (vacío)

Command: waitForElementNotPresent
Target: css=.confirmation-modal
Value: (vacío)

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

Command: assertElementPresent
Target: id=success-message
Value: (vacío)

Este ejemplo muestra cómo manejar elementos opcionales de forma elegante, asegurando que el test continúe correctamente independientemente de si aparece o no el modal de confirmación.

Consideraciones importantes

Al trabajar con comandos condicionales, es fundamental recordar que cada if debe tener su correspondiente end. Los bloques pueden anidarse, pero mantener la estructura simple mejora la legibilidad y el mantenimiento de los tests.

Las condiciones se evalúan en el momento de la ejecución, por lo que es importante asegurarse de que las variables estén actualizadas antes de usarlas en las expresiones condicionales.

Decisiones basadas en condiciones

La toma de decisiones en los tests automatizados va más allá de conocer la sintaxis de los comandos condicionales. Se trata de identificar correctamente cuándo nuestros tests necesitan adaptarse a diferentes escenarios y cómo estructurar esa lógica de manera eficiente.

Identificación de escenarios condicionales

Los tests lineales funcionan perfectamente cuando la aplicación web se comporta siempre de la misma manera. Sin embargo, las aplicaciones reales presentan variabilidad que requiere decisiones inteligentes durante la ejecución.

Elementos opcionales que pueden aparecer:

Command: open
Target: https://ejemplo.com/checkout
Value: (vacío)

Command: storeElementPresent
Target: css=.discount-banner
Value: bannerExists

Command: if
Target: ${bannerExists}
Value: (vacío)

Command: click
Target: css=.apply-discount-button
Value: (vacío)

Command: waitForText
Target: css=.total-price
Value: *descuento aplicado*

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

Flujos de usuario diferentes según el estado:

Command: storeText
Target: css=.cart-count
Value: itemCount

Command: if
Target: ${itemCount} == "0"
Value: (vacío)

Command: click
Target: id=browse-products
Value: (vacío)

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

Command: click
Target: id=proceed-checkout
Value: (vacío)

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

Estrategias para la toma de decisiones

Una estrategia efectiva consiste en evaluar primero el estado de la aplicación antes de decidir qué acciones ejecutar. Esto requiere capturar información relevante mediante comandos store y después usar esa información para tomar decisiones.

Patrón de evaluación previa:

Command: storeElementPresent
Target: id=login-form
Value: loginFormVisible

Command: storeElementPresent
Target: id=user-menu
Value: userMenuVisible

Command: if
Target: ${loginFormVisible}
Value: (vacío)

Command: type
Target: id=username
Value: usuario_test

Command: type
Target: id=password
Value: password123

Command: click
Target: id=login-button
Value: (vacío)

Command: else if
Target: ${userMenuVisible}
Value: (vacío)

Command: echo
Target: Usuario ya autenticado, continuando con el test
Value: (vacío)

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

Decisiones basadas en contenido dinámico

Las aplicaciones web modernas muestran contenido diferente según diversos factores: permisos del usuario, hora del día, configuración regional, o datos específicos del contexto. Los tests deben adaptarse a estas variaciones.

Manejo de permisos dinámicos:

Command: open
Target: https://app.ejemplo.com/dashboard
Value: (vacío)

Command: storeText
Target: css=.user-permissions
Value: userPermissions

Command: if
Target: ${userPermissions} == "full_access"
Value: (vacío)

Command: assertElementPresent
Target: id=admin-settings
Value: (vacío)

Command: click
Target: id=admin-settings
Value: (vacío)

Command: else if
Target: ${userPermissions} == "read_only"
Value: (vacío)

Command: assertElementNotPresent
Target: id=admin-settings
Value: (vacío)

Command: assertElementPresent
Target: id=view-reports
Value: (vacío)

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

Decisiones reactivas durante la ejecución

Algunos escenarios requieren decisiones reactivas, donde el test debe adaptarse a eventos inesperados o cambios en el estado de la aplicación durante la ejecución.

Manejo de errores temporales:

Command: click
Target: id=save-button
Value: (vacío)

Command: pause
Target: 2000
Value: (vacío)

Command: storeElementPresent
Target: css=.error-message
Value: errorPresent

Command: if
Target: ${errorPresent}
Value: (vacío)

Command: storeText
Target: css=.error-message
Value: errorText

Command: if
Target: ${errorText} == "Error temporal, intente nuevamente"
Value: (vacío)

Command: click
Target: id=retry-button
Value: (vacío)

Command: waitForElementNotPresent
Target: css=.error-message
Value: (vacío)

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

Command: echo
Target: Error no recuperable: ${errorText}
Value: (vacío)

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

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

Optimización de rutas de ejecución

Una decisión inteligente puede optimizar significativamente el tiempo de ejecución del test. En lugar de seguir siempre el mismo camino largo, el test puede tomar atajos cuando sea posible.

Acceso directo vs navegación completa:

Command: open
Target: https://app.ejemplo.com
Value: (vacío)

Command: storeElementPresent
Target: css=.quick-access-menu
Value: quickMenuAvailable

Command: if
Target: ${quickMenuAvailable}
Value: (vacío)

Command: click
Target: css=.quick-access-reports
Value: (vacío)

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

Command: click
Target: id=main-menu
Value: (vacío)

Command: click
Target: id=reports-section
Value: (vacío)

Command: click
Target: id=monthly-reports
Value: (vacío)

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

Patrones de decisión avanzados

Los patrones más sofisticados combinan múltiples condiciones y evalúan el contexto completo antes de decidir. Esto es especialmente útil en aplicaciones complejas con múltiples estados posibles.

Evaluación de contexto completo:

Command: storeText
Target: css=.page-title
Value: currentPage

Command: storeElementPresent
Target: css=.loading-indicator
Value: isLoading

Command: storeText
Target: css=.user-status
Value: userStatus

Command: if
Target: ${currentPage} == "Dashboard" && ${isLoading} == false && ${userStatus} == "active"
Value: (vacío)

Command: echo
Target: Contexto óptimo para ejecutar acciones principales
Value: (vacío)

Command: click
Target: id=primary-action
Value: (vacío)

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

Command: echo
Target: Esperando condiciones óptimas o ejecutando flujo alternativo
Value: (vacío)

Command: waitForText
Target: css=.page-title
Value: Dashboard

Command: waitForElementNotPresent
Target: css=.loading-indicator
Value: (vacío)

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

Mejores prácticas para decisiones efectivas

La clave del éxito en las decisiones condicionales radica en la preparación adecuada de la información necesaria y en mantener la lógica simple y comprensible.

Preparación de datos para decisiones:

• Capturar toda la información necesaria antes de evaluar condiciones
• Usar nombres descriptivos para las variables que almacenan estados
• Verificar la presencia y visibilidad de elementos de forma independiente
• Incluir comandos echo para documentar las decisiones tomadas durante la ejecución

Estructuración de la lógica condicional:

• Ordenar las condiciones de más específica a más general
• Agrupar acciones relacionadas dentro del mismo bloque condicional
• Evitar anidaciones excesivas que dificulten la lectura
• Incluir siempre un else para manejar casos no previstos

La implementación efectiva de decisiones condicionales transforma tests rígidos en herramientas adaptables que pueden manejar la variabilidad real de las aplicaciones web, proporcionando mayor robustez y confiabilidad en los procesos de testing automatizado.