Variables y almacenamiento de datos

Comandos store para capturar datos

Los comandos store son herramientas fundamentales que nos permiten extraer información de una página web y almacenarla en variables para su uso posterior en nuestros tests. Esta funcionalidad transforma nuestros tests de simples secuencias de acciones a pruebas inteligentes que pueden trabajar con datos dinámicos.

En lugar de escribir tests que siempre buscan los mismos valores fijos, podemos capturar información que cambia entre ejecuciones, como números de pedido, fechas generadas automáticamente o mensajes de confirmación únicos.

Tipos principales de comandos store

Selenium IDE proporciona tres comandos principales para capturar diferentes tipos de datos de los elementos web:

storeText - Captura el texto visible de un elemento

Este comando extrae el contenido textual que aparece en pantalla dentro de un elemento específico. Es especialmente útil para capturar mensajes, títulos, etiquetas o cualquier texto que el usuario puede ver.

Command: storeText
Target: css=.confirmation-message
Value: mensajeConfirmacion

En este ejemplo, capturamos el texto de un elemento con clase confirmation-message y lo almacenamos en una variable llamada mensajeConfirmacion.

storeValue - Captura el valor de campos de formulario

Se utiliza principalmente con elementos de entrada como campos de texto, áreas de texto, listas desplegables y otros controles de formulario. Extrae el valor actual del campo, no el texto visible.

Command: storeValue
Target: id=numeroFactura
Value: facturaId

Aquí capturamos el valor del campo con ID numeroFactura y lo guardamos en la variable facturaId.

storeAttribute - Captura atributos HTML específicos

Este comando nos permite extraer cualquier atributo HTML de un elemento, como href de enlaces, src de imágenes, class, id, o atributos personalizados.

Command: storeAttribute
Target: css=.download-link@href
Value: urlDescarga

En este caso, capturamos el atributo href de un enlace con clase download-link y lo almacenamos en urlDescarga.

Sintaxis y estructura de los comandos store

Todos los comandos store siguen un patrón consistente en su estructura:

• Command: El tipo de comando store que queremos ejecutar
• Target: El localizador del elemento del cual queremos capturar datos
• Value: El nombre de la variable donde almacenaremos la información capturada

Para storeAttribute, el target tiene una sintaxis especial que incluye el símbolo @ seguido del nombre del atributo:

localizador@nombreAtributo

Por ejemplo:

• id=miEnlace@href captura el atributo href
• css=.imagen@src captura la URL de la imagen
• xpath=//div[@class='info']@data-id captura un atributo personalizado

Ejemplos prácticos de captura de datos

Capturar un número de pedido generado automáticamente

Command: storeText
Target: css=.order-number
Value: numeroPedido

Extraer el valor de un campo calculado

Command: storeValue
Target: id=totalPrice
Value: precioTotal

Obtener la URL de un archivo PDF generado

Command: storeAttribute
Target: css=.pdf-download@href
Value: enlacePDF

Capturar un mensaje de error dinámico

Command: storeText
Target: xpath=//div[@class='error-message']
Value: mensajeError

Consideraciones importantes al usar comandos store

Al trabajar con comandos store, es fundamental seleccionar el localizador correcto que identifique de manera única el elemento que contiene los datos que necesitamos. Los elementos deben estar presentes y visibles en la página en el momento de la captura.

El timing es crucial cuando trabajamos con contenido dinámico. Si intentamos capturar datos de un elemento que aún no ha aparecido o cuyo contenido no se ha actualizado, obtendremos valores incorrectos o vacíos. En estos casos, debemos combinar los comandos store con comandos de espera como waitForElementPresent o waitForText.

Command: waitForElementPresent
Target: css=.order-confirmation
Value: 

Command: storeText
Target: css=.order-confirmation .order-id
Value: idPedido

Los nombres de variables deben ser descriptivos y seguir una convención consistente. Evita nombres genéricos como var1 o temp y opta por nombres que indiquen claramente qué contienen, como numeroFactura, fechaVencimiento o estadoPedido.

Es importante recordar que las variables capturadas con comandos store mantienen su valor durante toda la ejecución del test, lo que permite utilizarlas en múltiples pasos posteriores del mismo test.

Uso de variables en tests

Una vez que hemos capturado datos utilizando los comandos store, el verdadero poder se revela al usar esas variables en diferentes puntos de nuestros tests. Las variables nos permiten crear pruebas que se adaptan dinámicamente a los cambios en la aplicación, haciendo nuestros tests más robustos y realistas.

Sintaxis de variables en Selenium IDE

Para utilizar una variable previamente almacenada, empleamos la sintaxis ${nombreVariable} en cualquier campo Value de nuestros comandos. Esta notación le indica a Selenium IDE que debe sustituir la referencia por el valor real almacenado en esa variable.

Command: type
Target: id=searchBox
Value: ${numeroPedido}

En este ejemplo, si anteriormente capturamos un número de pedido en la variable numeroPedido, Selenium IDE escribirá ese valor en el campo de búsqueda.

Casos de uso prácticos con variables

Buscar un elemento creado dinámicamente

Después de crear un nuevo registro que genera un ID único, podemos capturarlo y usarlo para buscarlo posteriormente:

Command: storeText
Target: css=.new-record-id
Value: recordId

Command: type
Target: id=searchField
Value: ${recordId}

Command: click
Target: css=.search-button

Verificar datos en diferentes páginas

Capturamos información en una página y la verificamos en otra, manteniendo la coherencia de datos a lo largo del flujo:

Command: storeText
Target: css=.customer-name
Value: nombreCliente

Command: click
Target: css=.go-to-summary
Value: 

Command: assertText
Target: css=.summary-customer
Value: ${nombreCliente}

Rellenar formularios con datos previamente capturados

Command: storeValue
Target: id=originalEmail
Value: emailUsuario

Command: click
Target: css=.edit-profile
Value: 

Command: type
Target: id=confirmEmail
Value: ${emailUsuario}

Uso de variables en diferentes tipos de comandos

Las variables pueden utilizarse en prácticamente cualquier comando que acepte un valor, lo que proporciona una flexibilidad excepcional para crear tests dinámicos.

En comandos de interacción

Las variables funcionan perfectamente en comandos como type, select, y otros comandos de interacción:

Command: select
Target: id=categoryDropdown
Value: ${categoriaSeleccionada}

Command: type
Target: css=.comment-field
Value: Procesando pedido ${numeroPedido}

En comandos de verificación

Los comandos de verificación se vuelven mucho más potentes cuando utilizamos variables:

Command: verifyText
Target: css=.confirmation-message
Value: Su pedido ${numeroPedido} ha sido procesado correctamente

Command: assertValue
Target: id=calculatedTotal
Value: ${precioEsperado}

En localizadores dinámicos

Podemos incluso usar variables dentro de los localizadores, creando targets que se adaptan al contenido:

Command: click
Target: xpath=//button[text()='${nombreBoton}']
Value: 

Command: assertElementPresent
Target: css=.status-${estadoPedido}
Value: 

Combinación de texto fijo y variables

Una característica muy útil es la posibilidad de combinar texto fijo con variables en el mismo valor, creando mensajes o datos compuestos:

Command: type
Target: id=notes
Value: Pedido ${numeroPedido} - Cliente: ${nombreCliente} - Fecha: ${fechaProceso}

Command: assertText
Target: css=.welcome-message
Value: Bienvenido ${nombreUsuario}, su último acceso fue el ${fechaAcceso}

Flujo completo con variables

Un ejemplo completo que demuestra el ciclo de vida de las variables en un test:

// Capturar datos iniciales
Command: storeText
Target: css=.product-price
Value: precioOriginal

Command: storeAttribute
Target: css=.product-link@href
Value: urlProducto

// Usar variables en acciones
Command: click
Target: css=.add-to-cart
Value: 

Command: assertText
Target: css=.cart-total
Value: ${precioOriginal}

// Navegar usando la URL capturada
Command: open
Target: ${urlProducto}
Value: 

// Verificar consistencia de datos
Command: verifyText
Target: css=.product-price
Value: ${precioOriginal}

Buenas prácticas para el uso de variables

Validar antes de usar: Siempre verifica que una variable contenga el valor esperado antes de usarla en operaciones críticas. Puedes usar echo para imprimir el valor de la variable en los logs:

Command: echo
Target: ${numeroPedido}
Value: 

Nombres descriptivos: Utiliza nombres de variables que describan claramente su contenido. En lugar de var1, usa numeroFactura o emailCliente.

Scope de variables: Recuerda que las variables mantienen su valor durante toda la ejecución del test actual. Si ejecutas múltiples tests en secuencia, las variables no se comparten entre tests diferentes.

Manejo de valores vacíos: Ten en cuenta que si una variable no se ha inicializado o contiene un valor vacío, ${nombreVariable} se sustituirá por una cadena vacía. Esto puede causar comportamientos inesperados, especialmente en verificaciones.

Las variables transforman tests simples y rígidos en pruebas inteligentes y adaptativas que pueden manejar datos dinámicos, crear flujos de trabajo realistas y mantener la coherencia de datos a lo largo de procesos complejos. Esta capacidad es fundamental para crear suites de pruebas robustas que reflejen el comportamiento real de las aplicaciones web.