Automatización Sin Esfuerzo: Selenium con Python Paso a Paso

Este curso se concentra en como automatizar pruebas de paginas web usando Selenium. Cubre en forma extensa las diferentes formas de encontrar elementos usado el DOM y XPath. Xpath en un lenguaje muy pequeño para seleccionar nodos de un archivo XML. HTML es tratado como XML por XPath.   

Los ejemplos de este curso fueron probados en Firefox, Chrome e Internet Explorer. Para probar se hace uso de Unittest, aunque existen otros frameworks pero no se cubren en este curso.   

También veras las acciones más comunes y algunas no comunes en una pagina de internet, por ejemplo como darle clic a un botón o a una caja de selección, como verificar si un checkbox esta seleccionado, como seleccionar una opción en un drop down. Como obtener el texto o cualquier atributo de un elemento.   

Un poco mas alla de lo básico veras como cambiar el foco a alguna nueva ventana que se abra, o como cambarse a una alerta. Veras como realizar acciones en cadena ActionChains son utiles para crear acciones un poco mas complejas como seleccionar un menú dinamico que aparezca cuando el raton se mueve encima de un elemento.   

También aprenderás como manejar esperas Implicitas y Esperas Explicitas o en ingles (Implicit waits y Explicit waits)   

El curso termina explicando lo que se conoce como Page Object Model (POM) que es un patrón de diseño. O en otras palabras es una estrategia probada para optimizar la creacion de tus pruebas, este modelo ofrece que .   

• Tu código será más fácil de entender     

• Sea Fácil de mantener por cualquier persona   

• Tu Código sea reusable – porque usa el mismo script en varias pruebas   

Porque eso entra de las estrategias que pudieras seguir para generar cientos de casos de prueba en forma eficiente.    

Al final de este curso te sentiras con confianza para generar tus programas para probar tus  casos de prueba en una forma elegante y bien estructurada. 

El video comienza presentando el objetivo principal: enseñar a los espectadores cómo instalar Python para usarlo con Selenium, una herramienta poderosa para automatizar navegadores web. Primero, se introduce brevemente Python y Selenium, destacando la importancia de Python en la automatización y el desarrollo web y cómo Selenium utiliza este lenguaje para controlar las acciones del navegador de manera efectiva.

Luego, el video procede a guiar a los espectadores a través del proceso de descarga e instalación de Python. Se muestra la página oficial de Python y se señala la versión recomendada para descargar. Mientras se descarga, el video ofrece una explicación concisa pero detallada de los componentes que se instalarán, incluyendo el intérprete de Python y pip, el gestor de paquetes.

Una vez descargado Python, el video muestra paso a paso cómo ejecutar el instalador. Se hace especial énfasis en la importancia de marcar la opción "Add Python to PATH" para asegurar que Python se pueda ejecutar desde la línea de comandos en cualquier directorio. Durante la instalación, el narrador explica qué significa cada paso y cómo las diferentes opciones afectarán el uso de Python.

Después de la instalación, el video demuestra cómo verificar que Python y pip estén correctamente instalados, mostrando cómo abrir la línea de comandos, escribir los comandos para verificar las versiones de Python y pip, y explicando qué deberían ver los usuarios como resultado si todo está correctamente configurado.

A continuación, el video se mueve hacia la instalación de Selenium. Se explica qué es un WebDriver y por qué es necesario para Selenium. Luego, se muestra cómo usar pip para instalar el paquete de Selenium y se discute brevemente cómo actualizarlo en el futuro.

Finalmente, el video concluye con un resumen de los pasos realizados y ofrece consejos sobre cómo empezar a escribir scripts de automatización con Python y Selenium. También se anima a los espectadores a explorar más sobre Python y Selenium, proporcionando enlaces a recursos adicionales y comunidades en línea donde pueden aprender más y resolver dudas.

Para instalar Selenium, escribe cmd en tu barra de busqueda para abrir una consola de comandos de DOS, tienes que ir al directorio donde instalaste Python y después ir al folder scripts.

si no cambiaste el directorio por defecto durante la instalación, Python 3.6 se encuentra en

C:\Users\Gabriel Serrano\AppData\Local\Programs\Python\Python36

Puedes escribir dir y ves que ahí se encuentra pip.exe ese es el instalador de Python que sirve para instalar módulos casi en forma automática.

Es importante decir que cuando usas pip, necesitas estar conectado a internet pues pip bajara el modulo de internet antes de instalarlo.

Puedes ver los módulos que tienes instalados escribiendo “pip list”. Si acabas de instalar Python como yo, veras que tienes solamente dos módulos instalados: setuptools y pip.

Para instalar selenium simplemente escribe “pip install selenium” cuando presionas enter no se tarda casi nada y te despliega un mensaje indicando que la instalación fue exitosa.

Puedes volver a escribir el comando pip list para comprobar que selenium fue instalado. Si lo haces ves que ahora tienes pip, setuptools y selenium.

Geckodriver es un componente esencial para utilizar Selenium, una herramienta de automatización de navegador web, con el navegador Mozilla Firefox. Es un enlace entre los comandos de Selenium y el navegador Firefox, actuando como un servidor intermediario que traduce los comandos escritos en un script de Selenium a un formato que Firefox puede entender y ejecutar. Aquí te explico más detalles sobre qué es y cómo funciona:

Función de Geckodriver:

1. Traducción de Comandos: Geckodriver toma los comandos enviados por Selenium, los traduce a un protocolo que Firefox entiende (conocido como el protocolo Marionette), y luego envía estos comandos al navegador.

2. Interacción con Firefox: Cuando ejecutas un script de Selenium para realizar tareas automatizadas en Firefox (como abrir páginas web, hacer clic en elementos, rellenar formularios, etc.), Geckodriver facilita la comunicación entre tu script y el navegador.

Importancia en la Automatización de Pruebas:

• Compatibilidad: Cada navegador principal tiene su propio driver para asegurar la compatibilidad con Selenium. Chrome tiene Chromedriver, Internet Explorer tiene IEDriver, y Firefox utiliza Geckodriver.

• Estandarización: Geckodriver implementa el protocolo WebDriver, un estándar de la industria para la automatización de navegadores web, lo que asegura que los comandos y operaciones de Selenium se realicen de manera consistente en Firefox.

Uso en Proyectos de Selenium:

• Instalación y Configuración: Para usar Selenium con Firefox, necesitas descargar y configurar Geckodriver en tu entorno de desarrollo. Esto implica descargar el ejecutable de Geckodriver y colocarlo en una ubicación accesible para tu script de Selenium.

• Ejecución de Scripts: Cuando ejecutas un script de Selenium destinado a Firefox, el script inicia una instancia de Geckodriver, que a su vez abre y controla el navegador.

Actualizaciones y Mantenimiento:

• Desarrollo Activo: Geckodriver se actualiza regularmente para mantener la compatibilidad con las últimas versiones de Firefox y para incorporar mejoras y correcciones de errores.

• Versiones Compatibles: Es importante asegurarse de que la versión de Geckodriver que estás utilizando sea compatible con la versión de Firefox instalada en tu sistema.

En resumen, Geckodriver es un componente clave para la automatización de pruebas y tareas en Firefox utilizando Selenium. Proporciona una interfaz necesaria para que Selenium envíe comandos al navegador Firefox y reciba respuestas de este, permitiendo así la automatización efectiva de tareas en este navegador.

El sitio de internet que vamos a estar usando para todas nuestras pruebas es goodstartbooks.com/pruebas

Esta pagina fue creada para ti, para que hagas tus pruebas, tiene varios tipos de elementos, pro ejemplo un menú con una liga a otra pagina, tiene u textbox, una tabla que tiene formateada la primera fila, después veremos como probar los colores o clases, también veremos como obtener los valores dentro de la celda. Una lista, un grupo de check boxes, veremos como seleccionarlos después en el curso.   

Radiobutton, y grupo de radiobuttons , a la derecha tenemos un listbox para probar tambien y al final botones y un botón que despliega un mensaje   

Al final de la pagina para probar se encuentra un FRAME que una pagina web dentro de otra pagina web.

El video es una guía completa y detallada diseñada para enseñar a los espectadores cómo instalar GeckoDriver, un componente crucial para utilizar Selenium con el navegador Firefox. El video está pensado tanto para principiantes en automatización como para aquellos que ya tienen experiencia pero necesitan entender cómo configurar GeckoDriver específicamente.

Comienza con una introducción al propósito de GeckoDriver, explicando que es un enlace entre Selenium y el navegador Firefox y por qué es necesario para realizar pruebas automatizadas en este navegador. El narrador destaca la importancia de tener las herramientas adecuadas para la automatización y cómo GeckoDriver facilita la comunicación directa con Firefox.

Luego, el video guía a los espectadores a través del proceso de descarga de GeckoDriver. Muestra dónde encontrar el sitio web oficial y cómo navegar en él para seleccionar la versión correcta del driver, adecuada para el sistema operativo del espectador, ya sea Windows, MacOS o Linux. Mientras el archivo se descarga, el narrador explica qué es un 'driver' en el contexto de la automatización de navegadores y cómo GeckoDriver se integra con Selenium y Firefox.

Una vez descargado el archivo, el video muestra cómo extraer y almacenar el ejecutable de GeckoDriver. Se proporcionan instrucciones detalladas sobre qué directorios son los más adecuados para almacenarlo y cómo modificar las variables de entorno del sistema para incluir la ruta del ejecutable de GeckoDriver. Esto asegura que Selenium pueda localizar y utilizar GeckoDriver sin problemas.

El video continúa con una demostración de cómo verificar que GeckoDriver está instalado y configurado correctamente. Incluye cómo abrir la línea de comandos o terminal, cómo ejecutar GeckoDriver desde cualquier directorio y cómo interpretar los mensajes que aparecen para confirmar que la instalación fue exitosa.

El video es una guía educativa y detallada diseñada para enseñar a los espectadores cómo crear y ejecutar un programa sencillo en Python que utiliza Selenium para abrir una página web específica. Este tutorial está dirigido tanto a principiantes en programación y automatización como a aquellos con algo de experiencia que buscan comprender mejor cómo utilizar Selenium para interactuar con la web.

El video comienza con una breve introducción sobre qué es Selenium y por qué es una herramienta poderosa y popular para la automatización de tareas en navegadores web. Explica cómo Selenium permite a los usuarios simular acciones humanas reales en un navegador, como abrir páginas web, hacer clic en enlaces y llenar formularios.

Luego, el narrador introduce el lenguaje de programación Python y explica por qué es una excelente opción para trabajar con Selenium debido a su sintaxis clara y su amplio soporte comunitario. Se proporciona un resumen rápido de cómo configurar el entorno de desarrollo necesario para ejecutar scripts de Python, incluyendo la instalación de Python y un editor de texto o entorno de desarrollo integrado (IDE).

El video procede a guiar a los espectadores a través del proceso de instalación de Selenium utilizando pip, el gestor de paquetes de Python. Se explica cómo escribir y ejecutar un comando simple para instalar Selenium y se verifica que la instalación se haya completado correctamente.

A continuación, el video se sumerge en la escritura del script de Python. El narrador explica cada línea de código en detalle: desde importar las bibliotecas necesarias hasta escribir la lógica para iniciar un navegador, abrir una página y cerrar el navegador después de un breve retraso. El script es explicado de manera que incluso los espectadores sin experiencia previa en programación puedan seguirlo y entenderlo.

Mientras el script se va construyendo, el narrador también ofrece consejos sobre cómo evitar errores comunes y cómo leer y entender los mensajes de error que pueden surgir. Se enfatiza la importancia de leer la documentación de Selenium y Python para entender mejor las funciones utilizadas.

Una vez que el script está completo, el video muestra cómo ejecutarlo y qué esperar cuando se corre. El narrador demuestra cómo el navegador se inicia automáticamente, navega a la página web especificada y luego se cierra, todo controlado por el script.

El video es una guía instructiva y meticulosa diseñada para mostrar a los espectadores cómo desarrollar un programa sencillo utilizando Python y Selenium para abrir una página web en el navegador Microsoft Edge. Este tutorial está dirigido a una audiencia variada, incluyendo aquellos que son nuevos en la automatización de navegadores, así como a programadores con experiencia que buscan ampliar su conocimiento en Selenium con un enfoque específico en Edge.

El video comienza con una introducción clara y concisa sobre Selenium, destacando su papel y utilidad en la automatización de tareas en navegadores web. Se explica cómo Selenium simula interacciones humanas, permitiendo a los usuarios abrir páginas, interactuar con elementos en la web y mucho más. Luego, se enfatiza la relevancia de Microsoft Edge en el mercado actual de navegadores y por qué es importante saber cómo automatizar tareas en él.

A continuación, el narrador introduce el entorno de programación: Python. Se explica brevemente por qué Python es una elección popular debido a su sintaxis sencilla y su poderosa capacidad para interactuar con Selenium. Se proporcionan detalles sobre cómo configurar Python y un entorno de desarrollo adecuado, junto con instrucciones para instalar Selenium utilizando pip, el gestor de paquetes de Python.

El tutorial luego se centra en la configuración específica necesaria para utilizar Selenium con el navegador Edge. Se guía a los espectadores a través del proceso de descarga del WebDriver adecuado para Edge, explicando cómo localizar la versión correcta y dónde colocar el archivo ejecutable para que Selenium pueda interactuar con el navegador.

El video procede con la creación del script de Python. Cada línea de código es explicada detalladamente: desde importar las bibliotecas necesarias, iniciar el WebDriver de Edge, hasta comandos para abrir una página web específica. El narrador emplea un lenguaje claro y accesible, asegurando que incluso los principiantes puedan seguir y comprender el proceso.

A medida que el script se desarrolla, el narrador ofrece consejos útiles sobre cómo manejar posibles errores y proporciona información sobre cómo cada comando afecta la interacción del script con el navegador Edge. También se enfatiza la importancia de entender las peculiaridades de trabajar con Edge comparado con otros navegadores.

Una vez que el script está completo, el video demuestra su ejecución. Los espectadores pueden ver en tiempo real cómo el navegador Edge se lanza automáticamente, navega a la página web designada, y luego se cierra, todo bajo el control del script de Python.

El video concluye con un resumen de los conceptos cubiertos, reiterando la importancia de aprender a automatizar tareas en varios navegadores para ser un desarrollador de pruebas automatizadas versátil. Se alienta a los espectadores a experimentar con el código, modificarlo para abrir diferentes sitios o realizar tareas más complejas en Edge.

Para entender un poco que es el DOM es mas sencillo de entender si lo hacemos con un ejemplo. Puedes encontrar el archivo HTML que estoy usando en los recursos de esta lección. No importa Si abres el archivo en Chrome, Internet Explore o Firefox, si presionas F12 la consola de Javascript se abre, esta te permite ver los elementos en HTML. En este video estoy usando Chrome pero su funcionalidad es muy parecido en los otros navegadores.

¿Que son nodos?, nodo es un elemento en HTML, y los nodos están relacionados entre ellos. en esta pagina el encabezado (HEAD), el cuerpo (BODY) o la tabla (TABLE) son ejemplos de nodos    

El DOM (Document Object Model) representa el código HTML que fue usado en la página de internet. El DOM representa este código con una estructura de árbol de nodos.

En Firefox, Internet explore o Chrome puedes llamar a la consola del desarrollador presionando F12. Después puedes seleccionar el icono del “inspector” y puedes mover tu cursor alrededor de cualquier elemento que quieras seleccionar, el navegador muestra tips acerca del elemento donde tienes el mouse sin necesidad de selecionarlo, por ejemplo si pones tu mouse encima de la tabla, muestra su Id igual a “primera” entre otra información. Si le das clic en un elemento, te mostrara en donde se encuentra en el código.   

El inspector también trabaja cuando mueves tu raton en el código, iluminara el elemento en la pagina.   

Una vez mostrado el código puedes hacer decisiones para elegir el método que vas a usar para localizar ese elemento en Selenium. Lo veremos un poco mas adelante, pero en este caso puedes ver que la tabla tiene el atributo ID , y ese será un buen candidato para encontrar esta tabla en selenium. 

El video es una guía detallada y educativa diseñada para enseñar a los espectadores cómo utilizar XPath en Selenium para localizar elementos en las páginas web de manera eficiente y precisa. Este tutorial está dirigido tanto a principiantes en la automatización de navegadores web como a aquellos con experiencia previa que buscan profundizar su conocimiento en el uso de XPath con Selenium.

El video comienza con una breve introducción sobre qué es Selenium y cómo se utiliza para automatizar acciones en navegadores web. Luego, se introduce el concepto de XPath, explicando que es un lenguaje de consulta que permite navegar a través de los elementos y atributos en un documento HTML o XML. Se destaca su importancia como herramienta poderosa para localizar elementos en una página web, esencial para la automatización de pruebas y tareas en navegadores.

A continuación, el narrador explica los fundamentos de XPath, incluyendo la sintaxis básica y los tipos de XPath: absoluto y relativo. Se utiliza un lenguaje claro y ejemplos visuales para ilustrar cómo se construyen las expresiones XPath y cómo se pueden utilizar para identificar elementos específicos dentro de la estructura de una página web.

El video luego se sumerge en cómo usar XPath en el contexto de Selenium. Se muestra cómo instalar y configurar Selenium en el entorno de desarrollo preferido del espectador y cómo iniciar un navegador para pruebas automatizadas. Se explican las funciones de Selenium para interactuar con elementos web utilizando XPath, como find_element by.xpath y find_elements by.xpath.

El narrador guía a los espectadores a través de ejemplos prácticos y demostraciones en tiempo real de cómo escribir y ejecutar scripts que utilizan XPath para localizar y manipular elementos. Se cubren diferentes escenarios y desafíos comunes, como elementos con atributos dinámicos, estructuras complejas y cómo manejar situaciones en las que los elementos no se encuentran fácilmente.

Una vez establecido el contexto, el video se enfoca en el tema central: los predicados en XPath. Explica que los predicados se utilizan para refinar y precisar aún más las búsquedas de elementos, permitiendo a los usuarios seleccionar elementos específicos basados en condiciones y criterios detallados. Esta sección incluye una explicación de la sintaxis básica de los predicados y cómo se integran en las expresiones XPath comunes.

El narrador guía a los espectadores a través de ejemplos claros y concisos que demuestran cómo usar predicados para localizar elementos por su texto, atributos, posición y otras características. Se utilizan situaciones prácticas y comunes en la automatización de pruebas para ilustrar cómo los predicados pueden hacer que las búsquedas de elementos sean más específicas y robustas.

A medida que avanza el video, se proporcionan consejos útiles y mejores prácticas para escribir predicados efectivos y eficientes, así como para evitar errores comunes. Se discuten técnicas avanzadas, como el uso de funciones dentro de los predicados y cómo manejar elementos dinámicos o complejos en una página web.

Además, el video muestra cómo integrar expresiones XPath con predicados en scripts de Selenium. Se proporciona una demostración paso a paso de cómo escribir un script de Python que utiliza Selenium junto con expresiones XPath refinadas por predicados para interactuar con una página web de ejemplo

Para hacer cualquier tipo de pruebas en un elemento, lo primero que tienes que hacer es seleccionar ese elemento, XPath (XML path language) es un lenguaje usado para seleccionar nodos de un archivo XML. HTML es considerado XML.

XPath usa el DOM (Document Object Model) para navegar por el árbol XML y encontrar y seleccionar los nodos que se requieran usando un criterio   

WebDriver de Selenium puede usar XPath para localizar elementos usando consultas XPath    

Veamos un poco de la sintaxis de XPATH con unos ejemplos. Voy a usar FirePath solo para propósitos didácticos como mencione en un video anterior esta pequeña utilería Add-on de Firefox no funciona en las ultimas versiones de Firefox. Encontre que funcioana en la versión 55.0.   

Bueno, si no tienes instalado Firepath de todos modos los conceptos son sencillos y firePath es usado solamente es para aprender ya que no es necesario para usar selenium.

Los selectores CSS en Selenium son una forma poderosa y eficiente de localizar elementos dentro de una página web para interactuar con ellos durante la automatización de pruebas. Estos selectores utilizan la sintaxis de los Selectores de Cascading Style Sheets (CSS) para identificar elementos basados en sus atributos, contenido y relación con otros elementos en el Document Object Model (DOM) de la página.

¿Qué son los Selectores CSS?

1. Selectores de CSS: Son patrones que se utilizan para seleccionar los elementos que quieres estilizar en las hojas de estilo. En Selenium, estos mismos patrones se utilizan para identificar los elementos a los que quieres acceder y manipular con tus scripts de automatización.

2. Sintaxis: La sintaxis de los selectores CSS es concisa y permite identificar elementos a través de diferentes atributos como id, clase, tipo, atributos específicos, y sus relaciones con otros elementos en el DOM. Por ejemplo:

   • Por ID: #id

   • Por Clase: .clase

   • Por Atributo: [atributo='valor']

   • Combinaciones y descendientes: div > .clase

Ventajas de usar Selectores CSS en Selenium:

1. Eficiencia: Son generalmente más rápidos que XPath y otros localizadores, especialmente en navegadores modernos.

2. Potencia y Flexibilidad: Pueden localizar elementos por múltiples atributos y relaciones, lo que los hace muy versátiles.

3. Legibilidad: Su sintaxis es usualmente más simple y directa que la de XPath, haciendo que los scripts sean más fáciles de leer y mantener.

4. Compatibilidad: Son soportados por todos los navegadores modernos, lo que garantiza la coherencia en las pruebas automatizadas.

Ejemplos de Uso en Selenium:

Imagina que tienes un botón con el id "enviar" en tu página web. Puedes localizar este botón en Selenium con el siguiente código en Python:

pythonCopy code

boton_enviar = driver.find_element_by_css_selector("#enviar")

Si quieres encontrar todos los elementos que tienen una clase específica, podrías hacer algo como esto:

pythonCopy code

elementos_con_clase = driver.find_elements_by_css_selector(".mi-clase")

Consideraciones:

• Especificidad: Los selectores CSS operan bajo un principio de especificidad; los selectores más específicos tienen prioridad sobre los menos específicos. Esto puede ser muy útil, pero también requiere una comprensión clara de cómo está estructurado el DOM de tu página.

• Dinamismo: En páginas web dinámicas donde el DOM cambia frecuentemente, es crucial asegurarse de que tus selectores CSS sean robustos y puedan manejar estos cambios.

En resumen, los selectores CSS en Selenium son una herramienta fundamental para cualquier persona involucrada en la automatización de pruebas de aplicaciones web. Permiten localizar y manipular elementos de la página de forma eficiente, flexible y legible, facilitando la creación de scripts de pruebas automáticas robustas y mantenibles.

Existen varias formas para encontrar elementos en una página usando selenium. Generalmente usas la que es adecuada a la información que conoces del elemento:   

Buscar por          

Metodo        

ID          

find_element by.id        

Nombre          

find_element by.name        

XPath          

find_element by.xpath        

Texto          

find_element by.link_text        

Texto parcial          

find_element by.partial_link_text        

Tipo de elemento          

find_element by.tag_name        

Clase          

find_element by.class_name        

Css Selector          

find_element by.css_selector        

Y todos los métodos tienen un método similar para encontrar múltiples elementos, estos metodos regresan una lista.   

·         find_elements by.name   

·         find_elements by.xpath   

·         find_elements by.link_text   

·         find_elements by.partial_link_text   

·         find_elements by.tag_name   

·         find_elements by.class_name   

·         find_elements by.css_selector   

Para encontrar elementos por ID usando Selenium, puedes utilizar el método find_element by.id disponible en la instancia del WebDriver. El ID es un atributo único asignado a un elemento HTML en una página web, lo que lo hace un medio eficiente y confiable para localizar elementos.

Aquí te muestro cómo puedes hacerlo, utilizando Python como ejemplo:

Primero, necesitas importar Selenium y crear una instancia del WebDriver. Aquí se muestra cómo hacerlo con el navegador Chrome, pero el proceso es similar para otros navegadores:

Buenas Prácticas y Consideraciones:

• Elementos únicos: Asegúrate de que el ID del elemento sea único en la página para evitar confusiones.

• Manejo de Excepciones: Si intentas encontrar un elemento que no existe o cuyo ID no es correcto, Selenium lanzará una excepción NoSuchElementException. Es una buena práctica manejar estas excepciones en tu código.

• Espera: En páginas dinámicas, los elementos pueden no estar disponibles inmediatamente después de cargar la página. Considera usar las "esperas" (waits) de Selenium para manejar estas situaciones.

Para usar find_element con el método By.NAME en Selenium, primero necesitas entender que este método localiza elementos en una página web basándose en el atributo name de los elementos HTML. El atributo name es comúnmente utilizado en formularios web, como campos de entrada de texto, botones, radio buttons, entre otros. Aquí te muestro cómo puedes hacerlo, utilizando Python como lenguaje de ejemplo:

Paso 1: Importar Selenium y Crear una Instancia del WebDriver

Primero, importa Selenium y crea una instancia del WebDriver. Aquí te muestro cómo hacerlo con el navegador Chrome (asegúrate de tener el Chromedriver instalado y en tu PATH):

pythonCopy code

from selenium import webdriver

from selenium.webdriver.common.by import By

# Iniciar el WebDriver para Chrome

driver = webdriver.Chrome()

# Navegar a la página web donde quieres encontrar el elemento

driver.get("https://www.ejemplo.com")

Paso 2: Usar find_element con By.NAME

Ahora, para encontrar un elemento por su atributo name, utiliza el método find_element junto con By.NAME:

pythonCopy code

# Suponiendo que el elemento que quieres encontrar tiene un name "nombreElemento"

elemento = driver.find_element(By.NAME, "nombreElemento")

Paso 3: Interactuar con el Elemento Encontrado

Una vez que has localizado el elemento, puedes interactuar con él dependiendo de su tipo (campo de texto, botón, etc.):

pythonCopy code

# Si es un campo de texto, puedes enviar texto

elemento.send_keys("texto a escribir")

# Si es un botón, puedes hacer clic en él

elemento.click()

Paso 4: Cerrar el Navegador

No olvides cerrar el navegador al final de tu script para liberar recursos:

pythonCopy code

driver.quit()

Buenas Prácticas y Consideraciones:

• Elementos con Atributo name: Asegúrate de que el atributo name del elemento sea el correcto.

• Manejo de Excepciones: Si intentas encontrar un elemento que no existe o cuyo name no es correcto, Selenium lanzará una excepción NoSuchElementException. Es recomendable manejar estas excepciones adecuadamente.

• Espera Dinámica: En páginas que cargan contenido dinámicamente, considera usar las "esperas" (waits) de Selenium para asegurarte de que el elemento esté presente antes de intentar interactuar con él.

En resumen, find_element con By.NAME en Selenium es una herramienta útil para localizar elementos en una página web basándose en su atributo name. Este método es particularmente útil para interactuar con formularios y otros controles de entrada en la automatización de pruebas web.

(Test Case) unidad mínima en unnittest puede contener una o mas validaciones : Hereda de unittest TestCase class.

1. (Test Fixture) Es la preparación y terminación de todas tus pruebas. Un ejemplo de preparación que es común es abrir el navegador de internet y un ejemplo de terminación de todas tus pruebas es cerrar el navegador de internet.

2. (Test Suite) una colección o grupo de casos pruebas (Test Cases)

3. (Test Runner) La parte de unittest que Executa las pruebas

4. (Test Report) Reporte de los resultados de las pruebas

Veamos qué fácil es convertir nuestro ejemplo del video anterior a un caso de prueba de unnittest.

.¿Qué pasa si quieres correr mas pruebas en el mismo caso de pruebas? A manera de ejercicio, simplemente separemos las dos validaciones para que se ejecuten como dos pruebas distintas dentro del mismo

Para encontrar elementos por XPath en Selenium, utilizas el método find_element junto con el método By.XPATH. XPath, o XML Path Language, es un lenguaje de consulta que se usa para seleccionar nodos en un documento XML. En el contexto de una página web, que es básicamente un documento HTML (una forma de XML), XPath te permite navegar por la estructura de la página y seleccionar elementos basándose en su jerarquía y atributos.

Aquí te muestro cómo puedes hacerlo, utilizando Python como lenguaje de ejemplo:

Paso 1: Importar Selenium y Crear una Instancia del WebDriver

Primero, importa Selenium y crea una instancia del WebDriver. Aquí te muestro cómo hacerlo con el navegador Chrome (asegúrate de tener el Chromedriver instalado y en tu PATH):

pythonCopy code

from selenium import webdriver

from selenium.webdriver.common.by import By

# Iniciar el WebDriver para Chrome

driver = webdriver.Chrome()

# Navegar a la página web donde quieres encontrar el elemento

driver.get("https://www.ejemplo.com")

Paso 2: Usar find_element con By.XPATH

Para encontrar un elemento por XPath, utiliza el método find_element junto con By.XPATH:

pythonCopy code

# Suponiendo que tienes un XPath para el elemento que quieres encontrar

xpath_del_elemento = "/html/body/div[1]/div/div[2]/input"

elemento = driver.find_element(By.XPATH, xpath_del_elemento)

Puedes usar XPath de diferentes maneras, como:

• Absoluto: Comienza desde la raíz del documento HTML (/html) y navega por toda la estructura.

• Relativo: Comienza desde un elemento específico y es más flexible (//tagname[@attribute='value']).

Paso 3: Interactuar con el Elemento

Una vez que hayas localizado el elemento, puedes interactuar con él de diversas maneras:

python code:

# Si es un campo de texto, puedes enviarle texto

elemento.send_keys("texto a escribir")

# Si es un botón, puedes hacer clic en él

elemento.click()

Paso 4: Cerrar el Navegador

No olvides cerrar el navegador al final de tu script para liberar recursos:

pythonCopy code

driver.quit()

Buenas Prácticas y Consideraciones:

• Especificar XPath: Asegúrate de que tu XPath sea correcto y único para el elemento que deseas encontrar.

• Manejo de Excepciones: Selenium lanzará NoSuchElementException si el XPath no encuentra el elemento.

• Espera Dinámica: En páginas que cargan contenido dinámicamente, usa las esperas de Selenium para asegurarte de que el elemento esté presente antes de intentar interactuar con él.

En resumen, encontrar elementos por XPath es una técnica poderosa en Selenium para localizar elementos en una página web, especialmente cuando los métodos más simples como id o name no son aplicables o cuando necesitas localizar elementos con una estructura más compleja.

Encuentra elementos por Texto: find_element by.link_text

Encuentra elementos por Tipo de elemento: find_element by.tag_name

Todos los métodos que hemos visto hasta ahorita regresan solamente un elemento a la vez. Esos metodos tienen un metodo similar que te permite encontrar mas de un elemento a la vez, estos métodos te regresan una lista. Los nombres  de estos metodos empiezan con find elements, en plural.   

•             find_elements by.name     

•             find_elements by.xpath     

•             find_elements by.link_text     

•             find_elements by.partial_link_text     

•             find_elements by.tag_name     

•             find_elements by.class_name     

•             find_elements by.css_selector     

Y también el método general find_elements.

Esta lección muestra dos conceptos importantes

veremos como hacer clic en una liga que te lleva a una segunda pagina y en la segunda pagina encontraras un textbox, y en ese textbox escribiras algo usando el metodo send_keys()   

Ve al website de pruebas “goodstartbooks.com/pruebas” Primero vamos a ver como encuentar la liga  usando python para que nos lleve a la segunda pagina. Presiona F12 para abrir la consola si no esta abierta.   

Si generas Xpath usando Chrome o Firefox obtenemos una búsqueda relativa un poco larga   

“/html/body/div/div[1]/ul/li[1]/a[1]”

selección (checkboxes),  veamos primero como hacerlo en los botones de selección (en radiobuttons)

Primero veamos como identificar cada una de las opciones. Usando el inspector vemos que podemos encontrar usando id “RadioGroup1_0” y “RadioGroup1_1”   

Lo que vas a hacer en este ejercicio es darle clic al primer botón, esperar tres segundos y después darle clic al segundo botón. 

La clase “select” de selenium proporciona los siguientes metodos y recuerda que estos metodos solamente funcionan en elementos “select”   

deselect_all()          

En   elementos de opción multiple remueve todas las selecciones        

deselect_by_index(index)          

Remueve la   selección basado en la posición o índice        

deselect_by_value(value)          

Remueve la   selección basado en valor de la selección        

deselect_by_visible_text(text)          

Remueve la   seleccion basado en el texto desplegado        

select_by_index(index)          

Selecciona   basado en la posición o índice        

select_by_value(value)          

Selecciona   basado en valor de la selección        

select_by_visible_text(text)          

Selecciona   basado en el texto desplegado        

Muchos elementos tiene la propiedad text, una vez que seleccionas un elemento, puedes obtener el texto de ese elemento. Atributo attributo

Veamos como funciona, usando el inspector en Chome selecciona selecciona la celda que dice “azul’ en la tabla. Mueve tu raton al código y usando el botón derecho del raton, selecciona copy y después copy Xpath para generar la búsqueda usando Xpath.   

 Pega la búsqueda generada en Notepad para analizarla   

Vez que la fila puede ser seleccionada con id igual a noImportante  y a partir de ahí navega a la segunda celda “td”, tu cadena XPath se ve asi:   

//*[@id='noImportante']/td[2] 

Cuando presionas el botón que dice submit en la pagina de pruebas abrirá un nueva pagina, para cambiarse a otra pagina la clase Webdriver ofrece las siguientes propiedades que accesan al navegador:

Handle es como numero de referencia manejado por el sistema para cada ventana. Cada ventana tiene un handle, y el driver de selenium ofrece las siguientes propiedades:   

Propiedad          

Descripcion        

current_url          

URL de la pagina,        

current_window_handle          

Handle de la ventana actual        

name          

Nombre del navegador        

orientation          

Orientacion del dispositivo        

page_source          

Codigo de la pagina        

title          

Título de la pagina        

window_handles          

Los handles de todas las ventanas en la session actual        

Y para cambiarnos a una nueva ventana, alerta o frame, la clase Webdriver ofrece los siguientes métodos   

switch_to.window()        

switch_to.alert()        

switch_to.frame()        

Es posible que te encuentres en la situación de que cuando presiones un botón una alerta se muestre y tengas que presionar ok.

En nuestra pagina de pruebas el buton que dice alert  manda un mensaje con un botón de ok. El botón de ok no se encuentra en la pagina y por eso no puede ser encontrado con los metodos de selenium que hemos visto hasta ahora.   

En este caso, cuando la alerta aparezca debes llamar nuevamente el metodo switch_to.alert() y aceptar el mensaje. 

Cuando tienes elementos dentro de un Frame, Selenium trata esos elementos como si estuvieran en otra pagina y tienes que enfocar primero el Frame y después el elemento dentro del Frame.   

Analizemos primero lo que estamos diciendo.   

En tu Chrome, selecciona el inspector para encontrar el campo nombre que se encuentra en la parte de abajo de la pagina. Como puedes ver en el encabezado este campo se encuentra en la pagina 2 de pruebas. Si te muees un poco hacia arriba  en el código puedes ver en que todos estos elementos se encuentran dentro de un iFrame y de hecho el iFrame contiene toda una pagina llamada nueva pagina.   

Veamos un ejemplo para entender mejor:   

Escribamos nuevamente “Juan” en el campo de nombre, para lograr eso, necesitaremos enfocar el framework, y después encontrar el campo nombre que tiene id “Segundo” y por ultimo, una vez encontrado teclamos la palabra Juan.   

Pon atencion que iFrame puede ser encontrado usando el id = pruebas-iframe 

Acciones en cadena o ActionChains en inglés son una manera de automatizar interacciones básicas como movimientos del ratón ,  clic de los botones del ratón, o presionar una secuencia de teclas. ActionChains son utiles para crear acciones un poco mas complejas como seleccionar un menú dinamico que aparezca cuando el raton se mueve encima de un elemento.

Cuando agregas acciones al objeto ActionChains, las acciones se guardan en memoria hasta que se ejecuta el método perform y las accones se ejecutan en el orden que fueron agregadas. Acción    

Acciones pueden ser agregadas en cadena, una tras otra en una instruccion, por ejemplo este ejemplo sencillo donde primero se mueve el ratón hacia un doropdown, después se da click a una opción que aparece dinámicament, y por ultimo se ejecuta el metodo perform que ejecuta las dos acciones.   

ActionChains(driver).move_to_element(dropdown).click(opcionDinamica).perform() 

Problema con elementos escondidos

Veamos otro ejercicio que muestra un problema con implicitly wait   

Deja mostrarte en el navegador el botón que dice “continua” cuando refrescas el navegador va a desaparecer y después de cinco segundos va a volver a aparecer, para demostrar, aprieta el botón de refrescar, y el botón desaparece, después de cinco segundos reaparece.    

Veamos como localizar este botón. Presiona f12 y usando el inspector dale clic al botón de “continua” y observa que  el botón tiene un id igual a “proceed”, se puede usar el id para encontrar ese elemento.   

Abre el programa del ejemplo anterior y localiza el botón usando el id igual a “proceed”, usa find_element_by_id y cambia el nombre de la variable  a botón   

Si el botón es encontrado, borra todo lo de que se encuentra dentro de la condición if, y escibe botón.click() para darle clic al botón que acabas de encontrado.   

Antes de correr tu programa verifica que implicit_wait de 15 segundos se encuentra en tu código.   

Corre tu programa y guarda tus cambios,    

Al correr tu programa ves que falla inmediatamente porque no puede encontrar el elemento,  no importa que tengas una espera implícita de 15 segundos, no espera. porque? Porque el elemento si es encontrado pero se encuentra escondido, selenium se da cuenta de que el botón esta escondido y decide que no va a poder darle clic y termina.   

Este problema se puede resolver con una espera explicita. Primero veamos que son esperas explicitas.   

Explicit Waits      

Qué pasa cuando un botón toma mucho tiempo para desplegarse en la página y tú lo estas tratando de probar? La prueba fallara si Selenium no encuentra ese botón a tiempo.

Selenium ofrece dos soluciones a este problema: Espera Implícita y Espera Explícita (Implicit waits y Explicit waits)   

Implicit Waits       

una espera implícita es donde el Webdriver espera por un tiempo máximo determinado para encontrar un elemento cuando no está disponible. TAmbien es el tiempo de espera para que cualquier comando termine    

Este método solamente necesita ser llamado una sola vez por sesión.   

Esta configuración funciona de manera general cada vez que tratas de encontrar un elemento.   

El tiempo de espera funcionara durante la sesión, o sea hasta el webdriver se cierre. 

Explicit Waits

En una espera explícitas el Webdriver define un tiempo de espera para que ocurra una condición especifica.    

Cuando la condición ocurre antes de que el tiempo especificado termine, Webdriver continua con el codigo.    

Si la condición no ocurre en el tiempo predeterminado, un error “TimeOutException” ocurre.    

Solo por dar un ejemplo imagina que necesitas esperar 10 segundos para que aparezca una alerta, si no aparece en 10 segundos se recibe un error y si la alerta aparece antes, el programa continuo.   

Implícita    

Hay una clase de selenium que contiene las condiciones que pueden validarse con una espera explicita.   

Algunos metodos de la clase “Expected Condition”:   

expected_condition     

Expected Condicion            

Descripcion            

element_to_be_clickable()            

Espera por un   elemento y revisa que sea visible y habilitado para darle clic.            

element_to_be_selected()            

Espera a que el   elemento se seleccione            

presence_of_element_located()            

Espera hasta que el   element esta disponible en el DOM            

title_contains()            

Espera que el   título de la página contenga una cadena de caracteres            

visibility_of()            

Localiza el   elemento y verifica que sea visible y el tamaño del elemento sea mayor cero            

text_to_be_present_in_element()            

Localiza el element   y verifica que contenga un texto.            

WebdriverWait es la forma que Python implementa esperas explicita 

Page Object Model (POM) es un patrón de diseño. O en otras palabras es una estrategia probada para optimizar la creacion de tus pruebas, este modelo ofrece las siguientes ventajas.

• Tu código será más fácil de entender     

• Fácil de mantener por cualquier persona   

• Código reusable - use el mismo script en varias pruebas   

Como su nombre indica se crea una clase por cada página en tu prueba.   

Imagina por ejemplo que todas tus pruebas tienen que meter su usuario y contraseña antes de llegar a la pantallas que realmente se quieren probar, en lugar de escribir  lo mismo en todas tus pruebas, puedes crear una clase con la pagina 'Login" unicamente.   

Asi todas tus pruebas pueden usar esta clase.   

Si alguien decide cambiar el ID del campo de usuario en la pagina de Login. Solo tendrias que cambiar el acceso en un solo lugar sin tocar todas tus pruebas!