Mira la lección en vídeo
Accede al vídeo completo de esta lección y a más contenido exclusivo con el Plan Plus.
Desbloquear Plan PlusXPath absoluto vs relativo
Cuando trabajamos con localizadores XPath en Selenium IDE, es fundamental comprender la diferencia entre los dos tipos principales de expresiones XPath. Esta distinción afectará directamente la estabilidad y mantenibilidad de nuestros tests automatizados.
¿Qué es XPath absoluto?
El XPath absoluto es una expresión que especifica la ruta completa desde la raíz del documento HTML hasta el elemento objetivo. Siempre comienza con una barra diagonal simple (/) y describe cada nivel de la jerarquía DOM.
/html/body/div[1]/div[2]/form/input[3]
Este tipo de XPath funciona como una dirección postal completa: especifica exactamente cada "parada" desde el elemento raíz hasta nuestro destino. En Selenium IDE, cuando grabamos acciones, a veces se generan automáticamente XPaths absolutos si no encuentra localizadores más simples.
Características del XPath absoluto:
- Precisión máxima: Identifica elementos de forma muy específica
- Velocidad de localización: Puede ser ligeramente más rápido en algunos casos
- Dependencia estructural: Requiere que la estructura HTML permanezca exactamente igual
¿Qué es XPath relativo?
El XPath relativo busca elementos basándose en sus relaciones con otros elementos o sus atributos, sin necesidad de especificar la ruta completa desde la raíz. Siempre comienza con dos barras diagonales (//).
//input[@type='email']
//button[text()='Enviar']
//div[@class='usuario-panel']
Este enfoque es como dar direcciones flexibles: "busca cualquier botón que contenga el texto 'Enviar'" en lugar de "ve al segundo piso, tercera habitación, cuarta mesa, primer cajón".
Características del XPath relativo:
- Flexibilidad: Se adapta a cambios menores en la estructura
- Legibilidad: Más fácil de entender y mantener
- Robustez: Menos propenso a romperse por modificaciones del sitio web
Comparación práctica en Selenium IDE
Imaginemos que tenemos un formulario de registro en una página web. Veamos cómo se vería cada tipo de XPath:
HTML de ejemplo:
<html>
<body>
<div id="contenido">
<form class="registro">
<input type="text" name="usuario" placeholder="Nombre de usuario">
<input type="email" name="email" placeholder="Correo electrónico">
<button type="submit">Registrar</button>
</form>
</div>
</body>
</html>
XPath absoluto para el campo email:
/html/body/div/form/input[2]
XPath relativo para el mismo elemento:
//input[@type='email']
//input[@name='email']
//form[@class='registro']//input[2]
¿Cuándo usar cada tipo?
Usa XPath absoluto cuando:
- El elemento está en una posición muy específica que no cambiará
- Necesitas máxima precisión en un DOM muy simple
- Estás probando una aplicación con estructura HTML completamente estática
Usa XPath relativo cuando:
- La aplicación web sufre cambios frecuentes en su estructura
- Quieres que tus tests sean más mantenibles a largo plazo
- Trabajas con elementos que tienen atributos únicos identificativos
- El sitio web tiene contenido dinámico o estructura variable
Recomendación para Selenium IDE
En la práctica profesional, el XPath relativo es la opción recomendada para la mayoría de casos de uso. Selenium IDE intentará generar automáticamente el localizador más estable posible, pero debemos estar preparados para editarlo manualmente cuando sea necesario.
Cuando Selenium IDE grabe un XPath absoluto largo como /html/body/div[1]/div[3]/form/div[2]/input, considera cambiarlo por algo más robusto como //input[@name='email'] o //form[@class='contacto']//input[@type='email'].
Esta aproximación nos ahorrará tiempo de mantenimiento y hará que nuestros tests sean más resistentes a los cambios que inevitablemente ocurren durante el desarrollo de aplicaciones web.
Expresiones XPath útiles para testing
Guarda tu progreso
Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.
Más de 25.000 desarrolladores ya confían en CertiDevs
Una vez que comprendemos las diferencias entre XPath absoluto y relativo, es momento de aprender las expresiones XPath más prácticas para nuestros tests en Selenium IDE. Estas expresiones nos permitirán localizar elementos de forma eficiente cuando los localizadores básicos no son suficientes.
Expresiones XPath básicas por atributos
Las expresiones XPath más utilizadas en testing se basan en atributos HTML comunes. Estas son las que encontrarás con mayor frecuencia:
1 - Localizar por atributo de clase:
//div[@class='formulario-login']
//button[@class='btn-enviar']
//input[@class='campo-email']
2 - Localizar por tipo de input:
//input[@type='email']
//input[@type='password']
//input[@type='submit']
3 - Localizar por atributo name:
//input[@name='usuario']
//select[@name='pais']
//textarea[@name='comentarios']
Expresiones XPath con texto
Una de las características más útiles de XPath es su capacidad para localizar elementos basándose en el texto que contienen. Esto es especialmente valioso cuando los elementos no tienen IDs únicos:
1 - Texto exacto:
//button[text()='Enviar']
//a[text()='Iniciar sesión']
//span[text()='Total: 25,50 €']
2 - Texto que contiene una palabra:
//button[contains(text(), 'Enviar')]
//div[contains(text(), 'Error')]
//p[contains(text(), 'Bienvenido')]
Esta función contains() es especialmente útil porque permite coincidencias parciales, lo que hace nuestros tests más resistentes a pequeños cambios en el texto.
Expresiones XPath con múltiples condiciones
Cuando un solo atributo no es suficiente para identificar únicamente un elemento, podemos combinar múltiples condiciones usando operadores lógicos:
1 - Operador AND:
//input[@type='text' and @name='email']
//button[@class='btn' and text()='Guardar']
//div[@class='panel' and @id='configuracion']
2 - Operador OR:
//input[@name='usuario' or @name='email']
//button[text()='Enviar' or text()='Submit']
Expresiones XPath para elementos dinámicos
Los sitios web modernos frecuentemente generan IDs dinámicos o clases que cambian. Para estos casos, XPath ofrece funciones especializadas:
1 - Atributos que comienzan con un valor:
//div[starts-with(@id, 'mensaje-')]
//input[starts-with(@class, 'campo-')]
2 - Atributos que contienen un valor:
//div[contains(@class, 'error')]
//button[contains(@id, 'submit')]
//a[contains(@href, 'contacto')]
Navegación por jerarquía con XPath
XPath permite navegar por la estructura del DOM de forma muy flexible, lo que resulta útil cuando necesitamos localizar elementos basándonos en su relación con otros:
1 - Elemento hijo directo:
//form/div/input
//table/tbody/tr/td
2 - Cualquier descendiente:
//form//input[@type='email']
//div[@class='contenedor']//button
3 - Elemento por posición:
//table/tr[1] // Primera fila
//ul/li[2] // Segundo elemento de lista
//div[last()] // Último div
Uso de XPath en Selenium IDE
Selenium IDE incluye herramientas que facilitan el trabajo con XPath. Cuando grabamos acciones, la herramienta intenta generar automáticamente el localizador más estable posible, pero podemos editarlo manualmente:
1 - Generación automática: Durante la grabación, Selenium IDE analiza el elemento y sugiere el mejor localizador posible, incluyendo XPath cuando es necesario.
2 - Editor manual: En el campo "Target" podemos escribir directamente nuestras expresiones XPath personalizadas.
3 - Validación inmediata: Selenium IDE nos permite probar localizadores antes de ejecutar el test completo usando el botón de búsqueda junto al campo Target.
Consejos prácticos para XPath en testing
Prioriza la legibilidad: Una expresión XPath como //button[text()='Guardar cambios'] es más fácil de mantener que /html/body/div[3]/form/div[2]/button[1].
Usa contains() para flexibilidad: Cuando el texto o atributos pueden variar ligeramente, contains() hace que nuestros tests sean más robustos.
Combina atributos únicos: Si un elemento tiene múltiples atributos identificativos, combínalos para crear localizadores más específicos: //input[@type='email' and @name='usuario'].
Evita posiciones fijas: En lugar de //div[3]/p[2], usa atributos cuando sea posible: //div[@class='contenido']/p[@class='descripcion'].
Estas expresiones XPath cubren la mayoría de situaciones que encontrarás en testing web. La clave está en practicar con elementos reales y entender cuándo cada tipo de expresión es más apropiada para lograr tests estables y mantenibles.
Aprendizajes de esta lección de Selenium
- Comprender la diferencia entre XPath absoluto y relativo.
- Aprender a construir expresiones XPath básicas y avanzadas para localizar elementos web.
- Saber cuándo utilizar XPath absoluto o relativo según la estructura y dinámica del sitio.
- Aplicar funciones XPath como contains(), starts-with() y operadores lógicos para mayor flexibilidad.
- Utilizar XPath eficazmente en Selenium IDE para crear tests robustos y fáciles de mantener.
Completa este curso de Selenium y certifícate
Únete a nuestra plataforma de cursos de programación y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.
Asistente IA
Resuelve dudas al instante
Ejercicios
Practica con proyectos reales
Certificados
Valida tus conocimientos
Más de 25.000 desarrolladores ya se han certificado con CertiDevs