Vínculos de Selenium para Python

Lanzamiento 2

Baiju Muthukadan

23 de mayo de 2017
 Contenido

1 Instalación 3
1.1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Descargando Vínculos de Python para Selenium. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Controladores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Detallado instructions for Windows users . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Descargando Servidor Selenium . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Consiguiendo Comenzó 7
2.1 Sencillo Uso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Ejemplo Explicado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Usando Selenium para escribir pruebas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4 Caminar a través del ejemplo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.5 Usando Selenium con WebDriver remoto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

3 Navegando 13
3.1 Interactuando con la página . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2 Relleno en formularios14
3.3 y dejar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Arrastre
3.4 Mudanza entre ventanas y marcos 15
Ventana emergente 3.5 diálogos.................... 16
3.6 Navegación: historia y ubicación 16
3.7 Cookies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4 Localización Elementos 17
4.1 Localización por Id. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Localización por Nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.3 Localización por XPath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.4 Localización Hipervínculos por texto del enlace 20
4.5 Localización Elementos por Nombre de Etiqueta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.6 Localización Elementos por Nombre de Clase21
4.7 Localización Elementos por selectores CSS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

5 Esperas 23
Explícito Espera23
5.2 Implícito Espera24

6 Página Objetos 27

yo
 6.1 Prueba caso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6.2 Página clases de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
6.3 Página elementos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.4 Localizadores 29

7 WebDriver API 31
7.1 Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
7.2 Acción Cadenas35
7.3 Alertas 38
7.4 Especial Claves39
7.5 Localizar elementos Por41
7.6 Deseado Capacidades. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
7.7 Servicios públicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
7.8 Firefox Controlador Web43
7.9 Chrome WebDriver44
7.10 Remoto WebDriver. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
7.11 WebElement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
7.12 Interfaz de usuario Apoyo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
7.13 Color Soporte58
7.14 Esperado condiciones de soporte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

8 Apéndice: Preguntas Frecuentes 61

8.1 Cómo ¿para usar ChromeDriver? 61
8.2 Hace ¿Selenium 2 admite XPath 2.0? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
8.3 Cómo desplazarse hacia abajo hasta el final de una página . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
8.4 Cómo ¿Cómo guardar archivos automáticamente utilizando un perfil personalizado de Firefox? . . . . . . . . . . . . . . . . . . . . . . . . . . 62
8.5 Cómo ¿para subir archivos a las entradas de archivos?62
8.6 Cómo ¿Cómo usar Firebug con Firefox? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
8.7 Cómo ¿Tomar una captura de pantalla de la ventana actual?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

9 Índices y mesas 65
Índice de Módulos de Python 67

ii
 Vínculos de Selenium para Python, Versión 2

AutorBaiju Muthukadan
LicenciaEste documento está licenciado bajo unCreative Commons Atribución-CompartirIgual 4.0 Internacional
Licencia.

Nota: Esta no es una documentación oficial. La documentación oficial de la API está [Link]í.

Contenidos 1
Vínculos de Selenium Python, Lanzamiento 2

2 Contenidos
 CAPÍTULO 1

Instalación

Introducción
Los bindings de Selenium para Python proporcionan una API simple para escribir pruebas funcionales/de aceptación utilizando Selenium WebDriver.
A través de la API de Selenium Python, puedes acceder a todas las funcionalidades de Selenium WebDriver de una manera intuitiva.

Los enlaces de Selenium para Python proporcionan una API conveniente para acceder a los WebDrivers de Selenium como Firefox, Ie, Chrome, Remoto
etc. Las versiones de Python actualmente soportadas son 2.7, 3.5 y superiores.

Esta documentación explica la API de Selenium 2 WebDriver. La API de Selenium 1 / Selenium RC no se cubre aquí.

Descargando enlaces de Python para Selenium

Puedes descargar los enlaces de Python para Selenium desde elPágina de PyPI para el paquete selenium. Sin embargo, un mejor ap-
el enfoque sería usarpippara instalar el paquete selenium. Python 3.6 tiene pip disponible en elbiblioteca estándar. Usando
pip, puedes instalar selenium así:

pip instalar selenium

Puedesconsiderarusarentorno virtualpara crear entornos de Python aislados. Python 3.6 tienepyvenvque es casi
mismo que virtualenv.

Controladores

Selenium requiere un controlador para interactuar con el navegador elegido. Firefox, por ejemplo, requieregeckodriver, que
debe instalarse antes de que se puedan ejecutar los ejemplos a continuación. Asegúrate de que esté en tu PATH, por ejemplo, colócalo en /usr/bin o
/usr/local/bin.
El incumplimiento de este paso te dará un error [Link]: Mensaje: 'geck-
El ejecutable de odriver debe estar en PATH.

3
Bindings de Selenium para Python, versión 2

Otros navegadores compatibles tendrán sus propios controladores disponibles. Enlaces a algunos de los controladores de navegador más populares.
seguir.
Chrome:[Link]
Borde: [Link]
Firefox [Link]
Safari: No puedo acceder a enlaces externos o traducir su contenido.

Instrucciones detalladas para usuarios de Windows

Nota: Debe tener conexión a Internet para realizar esta instalación.

1. Instala Python 3.6 usando elMSI disponible en la página de descarga de [Link].

2. Inicie un símbolo del sistema utilizando el programa [Link] y ejecute el comando pip como se indica a continuación para instalar
selenio.

C:\Python35\Scripts\[Link] instalar selenium

Ahora puedes ejecutar tus scripts de prueba utilizando Python. Por ejemplo, si has creado un script basado en Selenium y lo has guardado
dentro de C:\my_selenium_script.py, puedes ejecutarlo así:

C:\Python35\[Link] C:\my_selenium_script.py

Descargando el servidor de Selenium

Nota: El servidor Selenium solo es necesario si deseas usar el WebDriver remoto. Ver elUsando Selenium
con WebDriver remotosección para más detalles. Si eres un principiante aprendiendo Selenium, puedes omitir esta sección
y proceder con el siguiente capítulo.

El servidor Selenium es un programa de Java. Se recomienda el entorno de ejecución de Java (JRE) 1.6 o una versión más nueva para ejecutarlo.
Servidor de Selenium.

Puedes descargar el servidor Selenium 2.x desde elpágina de descarga del sitio web de seleniumEl nombre del archivo debería ser algo-
cosa como esto: [Link]. Siempre puedes descargar la última versión 2.x
del servidor Selenium.
Si el Entorno de Ejecución de Java (JRE) no está instalado en su sistema, puede descargar elJRE desde el sitio web de Oracle.
Si estás utilizando un sistema GNU/Linux y tienes acceso root en tu sistema, también puedes usar tu sistema operativo
instrucciones para instalar JRE.
Si el comando ifjavacommand está disponible en la PATH (variable de entorno), puedes iniciar el servidor Selenium usando este comando.
mand:

java-jar [Link]

Reemplace 2.x.x con la versión actual del servidor Selenium que descargó del sitio.
Si JRE está instalado como un usuario no root y/o si no está disponible en la PATH (variable de entorno), puedes escribir el
ruta relativa o absoluta al comando java. De manera similar, puedes proporcionar una ruta relativa o absoluta al servidor de Selenium
archivo jar. Entonces, el comando se verá algo así:

4 Capítulo 1. Instalación
 Vínculos de Selenium para Python, Versión 2

/ruta/a/java-jar/ruta/a/[Link]

1.5. Descargando el servidor Selenium 5

Vínculos de Selenium para Python, Lanzamiento 2

6 Capítulo 1. Instalación
 CAPÍTULO 2

Empezando

Uso Simple

Si has instalado los enlaces de Selenium para Python, puedes empezar a usarlo desde Python así.

fromseleniumimportcontrolador de web
[Link]

controlador=[Link]()
[Link]("[Link]
afirmarPythonentitulo del controlador
elem=driver.find_element_by_name("q")
[Link]()
elem.send_keys("pycon")
elem.enviar_claves([Link])
afirmarNo se encontraron [Link] enfuente_de_página_del_controlador
[Link]()

El script anterior se puede guardar en un archivo (por ejemplo: python_org_search.py), luego se puede ejecutar de esta manera:

python python_org_search.py

El Python que estás ejecutando debería tener instalado el módulo selenium.

Ejemplo Explicado
El módulo [Link] proporciona todas las implementaciones de WebDriver. Implementaciones de WebDriver actualmente soportadas.
las implementaciones son Firefox, Chrome, IE y Remoto. La clase Keys proporciona teclas en el teclado como RETORNO, F1, ALT
etc.
desde selenium importarcontrolador
de navegador
[Link]

7
Selenium Python Bindings, Release 2

A continuación, se crea la instancia de WebDriver de Firefox.

controlador=[Link]()

El método [Link] navegará a una página dada por la URL. WebDriver esperará hasta que la página se haya cargado completamente.
(es decir, el evento 'onload' se ha activado) antes de devolver el control a su prueba o script. Vale la pena señalar que si su página
utiliza mucho AJAX al cargar, por lo que WebDriver puede no saber cuándo se ha cargado completamente.

[Link]("[Link]

La siguiente línea es una afirmación para confirmar que el título contiene la palabra “Python”:

afirmarPythonentítulo del conductor

WebDriver ofrece varias formas de encontrar elementos utilizando uno de los métodos find_element_by_*. Por ejemplo, el
El elemento de texto de entrada se puede localizar por su atributo de nombre utilizando el método find_element_by_name. Explicación detallada de
encontrar elementos está disponible en elLocalizando Elementoscapítulo

elem=driver.encontrar_elemento_por_nombre("q")

A continuación, estamos enviando teclas, esto es similar a ingresar teclas utilizando su teclado. Las teclas especiales se pueden enviar utilizando Keys.
clase importada de [Link]. Para estar seguros, primero borramos cualquier texto prellenado en la entrada.
campo (por ejemplo, 'Buscar') para que no afecte nuestros resultados de búsqueda:

[Link]()
elem.send_keys("pycon")
elem.enviar_claves([Link])

Después de enviar la página, deberías obtener el resultado si hay alguno. Para asegurarte de que se encuentren algunos resultados, haz un
afirmación:

afirmarNo se encontraron [Link] enfuente_de_la_página_del_controlador

Finalmente, se cierra la ventana del navegador. También puedes llamar al método quit en lugar de cerrar. El quit saldrá de todo el navegador.
mientras que 'cerrar' cerrará una pestaña, pero si solo había una pestaña abierta, por defecto la mayoría de los navegadores saldrán completamente.

[Link]()

Usando Selenium para escribir pruebas

Selenium se utiliza principalmente para escribir casos de prueba. El paquete Selenium en sí no proporciona una herramienta/marco de pruebas.
Puedes escribir casos de prueba utilizando el módulo unittest de Python. Las otras opciones para una herramienta/marco son [Link] y nose.
En este capítulo, utilizamos unittest como el marco de elección. Aquí está el ejemplo modificado que utiliza el módulo unittest.
Esta es una prueba de la funcionalidad de búsqueda de [Link]:

importarunittest
fromseleniumimportcontrolador de Web
de [Link] importarClaves

classPythonOrgSearch([Link]):

defsetUp(self):
[Link]=[Link]()

8 Capítulo 2. Empezando
 Vínculos de Selenium para Python, Versión 2

deftest_busqueda_en_python_org(self):
driver=[Link]
[Link]("[Link]
[Link]("Python", [Link])
elem=driver.buscar_elemento_por_nombre("q")
elem.send_keys("pycon")
elem.send_keys([Link])
afirmarNo se encontraron [Link] enfuente_de_la_página_del_controlador

deftearDown(self):
[Link]()

si__main__
[Link]()

Puedes ejecutar el caso de prueba anterior desde una terminal así:

python test_python_org_search.py
.
----------------------------------------------------------------------
PruebaRan1en15.566s

Está bien

El resultado anterior muestra que la prueba se ha completado con éxito.

Recorrido por el ejemplo

Inicialmente, se importan todos los módulos básicos requeridos. Elprueba unitariael módulo es un componente integrado de Python basado en JUnit de Java.
Este módulo proporciona el marco para organizar los casos de prueba. El módulo [Link] proporciona todo el
Implementaciones de WebDriver. Las implementaciones de WebDriver actualmente soportadas son Firefox, Chrome, Ie y Remoto.
La clase Keys proporciona teclas en el teclado como RETORNAR, F1, ALT, etc.

importarunittest
desde selenium importarwebdriver
[Link]

La clase de caso de prueba se hereda de [Link]. Heredar de la clase TestCase es la forma de informar al módulo unittest.
esto es un caso de prueba:

clasePythonOrgBuscar([Link]):

El setUp es parte de la inicialización, este método se llamará antes de cada función de prueba que vayas a escribir.
en esta clase de caso de prueba. Aquí estás creando la instancia de Firefox WebDriver.

defconfigurar(self):
[Link]=[Link]()

Este es el método de caso de prueba. El método de caso de prueba siempre debe comenzar con characterstest. La primera línea dentro de esto
crear una referencia local al objeto driver creado en el método setUp.

defprueba_buscar_en_python_org(self):
[Link]

2.4. Paseo a través del ejemplo 9

Vínculos de Selenium para Python, Lanzamiento 2

El método [Link] navegará a una página dada por la URL. WebDriver esperará hasta que la página se haya cargado completamente.
(es decir, el evento “onload” se ha disparado) antes de devolver el control a su prueba o script. Vale la pena señalar que si su página
si usa mucho AJAX al cargar, entonces WebDriver puede no saber cuándo se ha cargado completamente.

[Link]("[Link]

La siguiente línea es una afirmación para confirmar que el título tiene la palabra 'Python' en él:

[Link]("Python", [Link])

WebDriver ofrece varias formas de encontrar elementos utilizando uno de los métodos find_element_by_*. Por ejemplo, el
El elemento de entrada se puede localizar por su atributo name usando el método find_element_by_name. Explicación detallada de
encontrar elementos está disponible en elLocalizando elementoscapítulo

elem=driver.find_element_by_name("q")

A continuación, estamos enviando teclas, esto es similar a ingresar teclas usando tu teclado. Las teclas especiales se pueden enviar usandoKeys.
clase importada de [Link]:

elem.send_keys("pycon")
elem.send_keys([Link])

Después de enviar la página, deberías obtener resultados según la búsqueda si hay alguno. Para asegurarte de que se encuentren algunos resultados,
hacer una afirmación:

afirmarNo se encontraron [Link] enfuente_de_página_driver

El método tearDown se llamará después de cada método de prueba. Este es un lugar para realizar todas las acciones de limpieza. En el actual
método, la ventana del navegador se cierra. También puedes llamar al método salir en lugar de cerrar. La salida cerrará todo.
el navegador, mientras que cerrar cerrará una pestaña, pero si es la única pestaña abierta, por defecto la mayoría de los navegadores saldrán completamente.

deftearDown(self):
[Link]()

Las líneas finales son un código estándar para ejecutar la suite de pruebas:

si__main__
[Link]()

Usando Selenium con WebDriver remoto

Para usar el WebDriver remoto, deberías tener el servidor Selenium en ejecución. Para ejecutar el servidor, usa este comando:

java-jar [Link]

Mientras ejecutas el servidor de Selenium, podrías ver un mensaje que se asemeja a esto:

[Link].541INFO-Las instancias de RemoteWebDriver deben conectarse a: [Link]

˓→ 1:4444/wd/hub

La línea anterior dice que puedes usar esta URL para conectar con WebDriver remoto. Aquí hay algunos ejemplos:

desde selenium importwebdriver

[Link].desired_capabilitiesimportCapacidadesDeseadas

diez Capítulo 2. Comenzando

 Selenium Python Bindings, Lanzamiento 2

driver=[Link](
[Link]
desired_capabilities=[Link])

conductor=[Link](
[Link]
desired_capabilities=[Link])

driver=[Link](
[Link]
desired_capabilities=[Link])

Las capacidades deseadas son un diccionario, por lo que en lugar de usar los diccionarios predeterminados, puedes especificar los valores de manera explícita.
itly:

driver=[Link](
[Link]
desired_capabilities={'browserName':'htmlunit',
2
javascriptActivadoVerdadero})

2.5. Usando Selenium con WebDriver remoto 11

Enlaces de Python de Selenium, Lanzamiento 2

12 Capítulo 2. Empezando
 CAPÍTULO 3

Navegando

Lo primero que querrás hacer con WebDriver es navegar a un enlace. La forma normal de hacerlo es llamando a get
método

[Link]("[Link]

WebDriver esperará hasta que la página se haya cargado completamente (es decir, que se haya activado el evento onload) antes de devolver el control a
tu prueba o script. Vale la pena señalar que si tu página usa mucho AJAX al cargar, entonces WebDriver puede no saber cuándo
se ha cargado completamente. Si necesita asegurarse de que tales páginas estén completamente cargadas, puede usarespera.

Interactuando con la página

Simplemente poder ir a lugares no es muy útil. Lo que realmente nos gustaría hacer es interactuar con las páginas, o, más
específicamente, los elementos HTML dentro de una página. Primero que nada, necesitamos encontrar uno. WebDriver ofrece una serie de maneras
para encontrar elementos. Por ejemplo, dado un elemento definido como:

<input type="text"name="passwd"id="passwd-id"/>

podrías encontrarlo usando cualquiera de:

element=driver.find_element_by_id("passwd-id")
element=driver.find_element_by_name("passwd")
driver.find_element_by_xpath("//input[@id='passwd-id']")

También puedes buscar un enlace por su texto, ¡pero ten cuidado! ¡El texto debe ser una coincidencia exacta! También debes tener cuidado.
al usar XPATH en WebDriver. Si hay más de un elemento que coincide con la consulta, entonces solo el primero será
devuelto. Si no se puede encontrar nada, se generará una NoSuchElementException.
WebDriver tiene una API "basada en objetos"; representamos todos los tipos de elementos usando la misma interfaz. Esto significa
que aunque puedas ver muchos métodos posibles que podrías invocar cuando presionas la tecla de autocompletar de tu IDE
combinación, no todos tendrán sentido o serán válidos. ¡No te preocupes! WebDriver intentará hacer lo correcto,
y si llamas a un método que no tiene sentido (“setSelected()” en una etiqueta “meta”, por ejemplo) se lanzará una excepción
levantado.

13
Vínculos de Selenium para Python, Versión 2

Entonces, tienes un elemento. ¿Qué puedes hacer con él? Primero que nada, puede que quieras ingresar algún texto en un campo de texto:

elemento.enviar_claves("algún texto")

Puedes simular presionar las teclas de flecha usando la clase “Keys”:

elemento.enviar_teclas(" y algo", Claves.FLECHA_ABAJO)

Es posible enviar teclas a cualquier elemento, lo que hace posible probar atajos de teclado como los que se utilizan
en GMail. Un efecto secundario de esto es que escribir algo en un campo de texto no lo borrará automáticamente. En su lugar, lo que tú
el tipo se añadirá a lo que ya hay. Puedes borrar fácilmente el contenido de un campo de texto o área de texto con clear
método

[Link]()

Rellenar formularios

Ya hemos visto cómo ingresar texto en un área de texto o campo de texto, pero ¿qué pasa con los otros elementos? Puedes 'alternar'
el estado del menú desplegable, y puedes usar "setSelected" para establecer algo como una etiqueta OPTION seleccionada. Manejar con
SELECTtags no está tan mal:

element=driver.find_element_by_xpath("//select[@name='name']")
elemento.encontrar_elementos_por_nombre_de_etiqueta("opción")
paraopciónentodas_opciones
imprimir("El valor es:"%s%opción.get_atributo("valor")
opción.hacer_clic()

Esto encontrará el primer elemento "SELECT" en la página y recorrerá cada una de sus opciones, imprimiendo
sus valores, y seleccionando cada uno por turno.

Como puedes ver, esta no es la forma más eficiente de manejar elementos SELECT. Las clases de soporte de WebDriver
incluye uno llamado 'Seleccionar', que proporciona métodos útiles para interactuar con estos:

desde [Link] importarSeleccionar

select=Seleccionar(driver.find_element_by_name('name'))
select.select_by_index(indice)
select.select_by_visible_text("texto")
select.select_by_value(valor)

WebDriver también ofrece funciones para deseleccionar todas las opciones seleccionadas:

seleccionar=Seleccionar(driver.find_element_by_id('id'))
seleccionar.deseleccionar_todo()

Esto deseleccionará todas las OPCIONES del primer SELECT en la página.

Supongamos que en una prueba, necesitamos la lista de todas las opciones seleccionadas por defecto, la clase Select proporciona un método de propiedad que devuelve
una lista
seleccionar=Seleccionar(controlador.encontrar_elemento_por_xpath("xpath"))
select.todas_las_opciones_seleccionadas

Para obtener todas las opciones disponibles:

opciones=[Link]

14 Capítulo 3. Navegando
 Vínculos de Selenium para Python, Versión 2

Una vez que hayas terminado de completar el formulario, probablemente quieras enviarlo. Una forma de hacerlo sería encontrar el
botón de 'enviar' y haz clic en él:

# Suponga que el botón tiene el ID "submit" :)

driver.find_element_by_id("submit").click()

Alternativamente, WebDriver tiene el método conveniente “submit” en cada elemento. Si llamas a esto en un elemento dentro de
un formulario, WebDriver caminará por el DOM hasta encontrar el formulario que lo rodea y luego llamará a submit en ese.
si no está en un formulario, entonces se generará la NoSuchElementException:

[Link]()

Arrastrar y soltar

Puedes usar arrastrar y soltar, moviendo un elemento por una cierta cantidad, o sobre otro elemento:

element=driver.find_element_by_name("source")
objetivo=controlador.encontrar_elemento_por_nombre("objetivo")

[Link]ón
CadenasDeAcción=ActionChains(controlador)
action_chains.arrastrar_y_soltar(elemento, objetivo).realizar()

Navegando entre ventanas y marcos

Es raro que una aplicación web moderna no tenga ningún marco o que esté limitada a una sola ventana. WebDriver
admite moverse entre ventanas nombradas utilizando el método "switch_to_window":

driver.switch_to_window("windowName")

Todas las llamadas a driver ahora se interpretarán como dirigidas a la ventana particular. Pero, ¿cómo sabes la
¿nombre de la ventana? Echa un vistazo al javascript o al enlace que la abrió:

<a href="[Link]" target="windowName">Haz clic aquí para abrir una nueva ventana</a>

Alternativamente, puedes pasar un "manejador de ventana" al método "switch_to_window()". Sabiendo esto, es posible que
itera sobre cada ventana abierta así:

paramangoenmanejadores_de_ventanas:
driver.cambiar_a_ventana(handle)

Tambiénpuedesmovertedeunmarcoaotro(odentrodeiframes):

driver.switch_to_frame("nombreDelMarco")

Es posible acceder a submarcos separando la ruta con un punto, y también puedes especificar el marco por su índice.
Eso es:

driver.switch_to_frame("[Link]")

iría al marco llamado "child" del primer submarco del marco llamado "frameName". Todos los marcos son evaluados
como si viniera de *arriba*.

3.3. Arrastrar y soltar 15

Bindings de Selenium para Python, versión 2

Una vez que hayamos terminado de trabajar en los marcos, tendremos que regresar al marco principal, lo que se puede hacer utilizando:

driver.switch_to_default_content()

Diálogos emergentes

Selenium WebDriver tiene soporte integrado para manejar cuadros de diálogo emergentes. Después de que hayas activado una acción que
abre una ventana emergente, puedes acceder a la alerta con lo siguiente:

alerta=driver.cambiar_a_alerta()

Esto devolverá el objeto de alerta que está actualmente abierto. Con este objeto ahora puedes aceptar, descartar, leer su contenido o incluso
escribe en un aviso. Esta interfaz funciona igualmente bien en alertas, confirmaciones, avisos. Consulta la documentación de la API
para más información.

Navegación: historia y ubicación

Anteriormente, cubrimos navegar a una página usando el comando “get” ([Link]("[Link]
Como has visto, WebDriver tiene una serie de interfaces más pequeñas, enfocadas en tareas, y la navegación es una tarea útil.
Para navegar a una página, puedes usar el método get:

[Link]("[Link]

Para moverte hacia atrás y hacia adelante en el historial de tu navegador:

[Link]()
[Link]()

Tenga en cuenta que esta funcionalidad depende completamente del controlador subyacente. Es posible que algo
pueden ocurrir sorpresas cuando llames a estos métodos si estás acostumbrado al comportamiento de un navegador sobre otro.

Galletas
Antes de que dejemos estos próximos pasos, es posible que te interese entender cómo usar cookies. Primero que nada, necesitas
estar en el dominio para el cual la cookie será válida:

Ve al dominio correcto
[Link]("[Link]

Ahora establece la cookie. Esta es válida para todo el dominio

cookie = {‘name’ : ‘foo’, ‘value’ : ‘bar’}
driver.agregar_cookie(cookie)

# Y ahora muestra todas las cookies disponibles para la URL actual

driver.obtener_galletas()

16 Capítulo 3. Navegando
 CAPÍTULO 4

Localizando elementos

Existen varias estrategias para localizar elementos en una página. Puedes usar la más adecuada para tu caso. Selenium
proporciona los siguientes métodos para localizar elementos en una página:

•encontrar_elemento_por_id

•encontrar_elemento_por_nombre

•encontrar_elemento_por_xpath

•encontrar_elemento_por_texto_enlace

•encontrar_elemento_por_texto_de_enlace_parcial

•encontrar_elemento_por_nombre_de_etiqueta

•encontrar_elemento_por_nombre_de_clase

•encontrar_elemento_por_selector_css

Para encontrar múltiples elementos (estos métodos devolverán una lista):

•encontrar_elementos_por_nombre

•encontrar_elementos_por_xpath

•encontrar_elementos_por_texto_enlace

•encontrar_elementos_por_texto_enlazado_parcial

•encontrar_elementos_por_nombre_de_etiqueta

•encontrar_elementos_por_nombre_de_clase

•encontrar_elementos_por_selector_css

Además de los métodos públicos mencionados anteriormente, hay dos métodos privados que pueden ser útiles con localizadores en la página.
objetos. Estos son los dos métodos privados: encontrar_elemento y encontrar_elementos.

Ejemplo de uso:

17
Bindings de Selenium para Python, Lanzamiento 2

desde [Link] importarPor

driver.find_element([Link],'//button[text()="Algún texto"]')
driver.find_elements([Link],'//button')

Estos son los atributos disponibles para Byclass:

id
xpath
texto del enlace
texto del enlace parcial
nombre
nombre de etiqueta
nombre de clase
selector css

Localizando por Id

Utiliza esto cuando conozcas el atributo id de un elemento. Con esta estrategia, el primer elemento con el valor del atributo id
se devolverá la ubicación que coincida. Si ningún elemento tiene un atributo matchingid, se lanzará una NoSuchElementException
será elevado.
Por ejemplo, considera el código fuente de esta página:

<html>
<cuerpo>
<formid="loginForm">
<input name="username" type="text"/>
<input name="password" type="password"/>
<inputname="continue"type="submit"value="Login"/>
</form>
</cuerpo>
<html>

El elemento del formulario se puede localizar así:

driver.find_element_by_id('loginForm')

Localización por Nombre

Usa esto cuando conozcas el atributo nombre de un elemento. Con esta estrategia, el primer elemento con el valor del atributo nombre
se devolverá la ubicación que coincida. Si ningún elemento tiene un atributo matchingname, se lanzará una NoSuchElementException.
se aumentará.
Por ejemplo, considera el código fuente de esta página:

<html>
<cuerpo>
<formid="loginForm">
<input name="nombredeusuario" type="text"/>
<input name="password" type="password"/>
continuar
continuar

18 Capítulo 4. Localizando Elementos

 Vínculos de Selenium para Python, Versión 2

</form>
</body>
<html>

Los elementos de nombre de usuario y contraseña se pueden localizar de esta manera:

driver.find_element_by_name('username')
driver.find_element_by_name('password')

Esto dará el botón de 'Iniciar sesión' ya que ocurre antes del botón de 'Limpiar':

continuar=controlador.encontrar_elemento_por_nombre('continuar')

Ubicación por XPath

XPath es el lenguaje utilizado para localizar nodos en un documento XML. Dado que HTML puede ser una implementación de XML
(XHTML), los usuarios de Selenium pueden aprovechar este poderoso lenguaje para seleccionar elementos en sus aplicaciones web. XPath
se extiende más allá (así como apoya) los métodos simples de localización por id o atributos de nombre, y abre todo tipo de
de nuevas posibilidades como localizar la tercera casilla de verificación en la página.

Una de las principales razones para usar XPath es cuando no tienes un atributo id o name adecuado para el elemento que
desea localizar. Puede usar XPath para ubicar el elemento en términos absolutos (no aconsejado) o relativo a un elemento
que tiene un atributo id o name. Los localizadores XPath también se pueden usar para especificar elementos a través de atributos distintos de id
y nombre.
Los XPaths absolutos contienen la ubicación de todos los elementos desde la raíz (html) y, como resultado, es probable que fallen con solo
el más mínimo ajuste a la aplicación. Al encontrar un elemento cercano con un atributo id o name (idealmente un elemento padre
elemento) puedes localizar tu elemento objetivo basado en la relación. Esto es mucho menos probable que cambie y puede hacer
tus pruebas más robustas.
Por ejemplo, considera el código fuente de esta página:

<html>
<cuerpo>
<formid="loginForm">
<input name="username" type="text"/>
<input name="password" type="password"/>
<inputname="continue"type="submit"value="Login"/>
continuar
</form>
</cuerpo>
<html>

Los elementos del formulario se pueden localizar así:

driver.find_element_by_xpath("/html/body/form[1]")
driver.find_element_by_xpath("//form[1]")
driver.find_element_by_xpath("//form[@id='loginForm']")

1. Ruta absoluta (se rompería si el HTML se cambiara solo ligeramente)

2. Primer elemento de formulario en el HTML

3. El elemento de formulario con atributo llamado id y el valor loginForm

El elemento de nombre de usuario se puede localizar de esta manera:

4.3. Localización por XPath 19

Bindings de Selenium para Python, Versión 2

nombre_de_usuario=controlador.encontrar_elemento_por_xpath("//form[input/@name='nombre_de_usuario']")

driver.find_element_by_xpath("//form[@id='loginForm']/input[1]")
nombre_de_usuario=driver.find_element_by_xpath("//input[@name='nombre_de_usuario']")

1. Primer elemento de formulario con un elemento hijo de entrada con atributo llamado nombre y el valor nombre de usuario

2. Primer elemento hijo de la forma con el atributo llamado id y el valor loginForm

3. Primer elemento de entrada con atributo llamado 'name' y el valor username
El elemento del botón "Limpiar" se puede localizar de esta manera:

botón_claro=driver.find_element_by_xpath("//input[@name='continue'][@type='button']
˓→ ")

botón_borrar=driver.find_element_by_xpath("//form[@id='loginForm']/input[4]")

1. Entrada con un atributo llamado nombre y el valor continuar y un atributo llamado tipo y el valor botón
2. Cuarto elemento hijo de entrada del elemento formulario con atributo llamado id y valor loginForm
Estos ejemplos cubren algunos conceptos básicos, pero para aprender más, se recomiendan las siguientes referencias:

• Tutorial de XPath de W3Schools

• Recomendación W3C XPath
• Tutorial de XPath- con ejemplos interactivos.
También hay un par de complementos muy útiles que pueden ayudar a descubrir el XPath de un elemento:
• Verificador de XPath- sugiere XPath y se puede utilizar para probar los resultados de XPath.
• Firebug- Las sugerencias de XPath son solo una de las muchas funciones poderosas de este complemento tan útil.
• Ayudante de XPath- para Google Chrome

Localizando hipervínculos por texto del enlace

Utiliza esto cuando conozcas el texto del enlace utilizado dentro de una etiqueta ancla. Con esta estrategia, el primer elemento con el
se devolverá el valor del texto del enlace que coincida con la ubicación. Si ningún elemento tiene un atributo de texto de enlace coincidente, un
Se generará NoSuchElementException.
Por ejemplo, considera el código fuente de esta página:

<html>
<cuerpo>
<p>¿Estás seguro de que quieres hacer esto?</p>
<a href="[Link]">Continuar</a>
<a href="[Link]">Cancelar</a>
</body>
<html>

El enlace [Link] se puede localizar así:

driver.find_element_by_link_text('Continuar')
driver.find_element_by_partial_link_text('Conti')

20 Capítulo 4. Localizando Elementos

 Vínculos de Selenium para Python, versión 2

Localizando elementos por nombre de etiqueta

Utiliza esto cuando quieras localizar un elemento por su nombre de etiqueta. Con esta estrategia, el primer elemento con el nombre de etiqueta dado
será devuelto. Si ningún elemento tiene un nombre de etiqueta coincidente, se generará una NoSuchElementException.

Por ejemplo, considera el código fuente de esta página:

<html>
<cuerpo>
<h1>Bienvenido</h1>
<p>El contenido del sitio va aquí.</p>
</body>
<html>

El elemento de encabezado (h1) se puede ubicar de la siguiente manera:

driver.encontrar_elemento_por_nombre_de_etiqueta('h1')

Ubicación de elementos por nombre de clase

Usa esto cuando quieras localizar un elemento por el nombre del atributo de clase. Con esta estrategia, el primer elemento
se devolverá el nombre del atributo de clase que coincide. Si ningún elemento tiene un nombre de atributo de clase coincidente, un
Se generará NoSuchElementException.
Por ejemplo, considera el código fuente de esta página:

<html>
<cuerpo>
<p class="content">El contenido del sitio va aquí.</p>
</body>
<html>

El elemento “p” se puede localizar de esta manera:

contenido=driver.encontrar_elemento_por_clase_nombre('contenido')

Ubicación de elementos por selectores CSS

Utiliza esto cuando quieras localizar un elemento mediante la sintaxis del selector CSS. Con esta estrategia, el primer elemento con el
se devolverá un selector CSS coincidente. Si ningún elemento tiene un selector CSS coincidente, se lanzará una NoSuchElementException
se aumentará.
Por ejemplo, considera el código fuente de esta página:

<html>
<cuerpo>
<p class="content">El contenido del sitio va aquí.</p>
</cuerpo>
<html>

El elemento “p” se puede localizar así:

4.5. Localización de elementos por nombre de etiqueta 21

Vínculos de Selenium Python, versión 2

contenido=controlador.encontrar_elemento_por_selector_css('[Link]')

Sauce Labs tiene buena documentaciónsobre los selectores CSS.

veintidós Capítulo 4. Localizando Elementos

 CAPÍTULO 5

Espera

En estos días, la mayoría de las aplicaciones web utilizan técnicas AJAX. Cuando una página es cargada por el navegador, los elementos
dentro de esa página puede cargar en diferentes intervalos de tiempo. Esto dificulta localizar elementos: si un elemento aún no está
si no está presente en el DOM, una función de localización generará una excepción anElementNotVisibleException. Usando esperas, podemos resolver
este problema. La espera proporciona un margen entre las acciones realizadas, principalmente localizar un elemento o cualquier otra operación
con el elemento.
Selenium Webdriver proporciona dos tipos de esperas: implícita y explícita. Una espera explícita hace que WebDriver espere por un
una condición cierta para ocurrir antes de continuar con la ejecución. Una espera implícita hace que WebDriver consulte el DOM
por un cierto período de tiempo al intentar localizar un elemento.

Espera Explícita
Una espera explícita es un código que defines para esperar a que ocurra una cierta condición antes de continuar con el código.
El caso extremo de esto es [Link](), que establece la condición a un período de tiempo exacto para esperar. Hay algunos
métodos de conveniencia proporcionados que te ayudan a escribir código que esperará solo el tiempo necesario. WebDriverWait en
la combinación con ExpectedCondition es una forma en que se puede lograr esto.

fromseleniumimportwebdriver
from [Link] importPor
[Link]
[Link] esperadascomoCE

driver=[Link]()
[Link]("[Link]
intentar:
elemento=WebDriverWait(driver,10).hasta(
EC.presencia_de_elemento_ubicado(([Link], "miElementoDinámico"))
)
finalmente:
[Link]()

23
Vínculos de Selenium para Python, Versión 2

Esto espera hasta 10 segundos antes de lanzar una TimeoutException a menos que encuentre el elemento para devolver dentro de 10 segundos.
WebDriverWait por defecto llama a la ExpectedCondition cada 500 milisegundos hasta que devuelve exitosamente.
el retorno exitoso es para el tipo ExpectedCondition es Boolean devolver verdadero o no nulo devolver valor para todas las otras Expected-
Tipos de condición.
Condiciones Esperadas
Hay algunas condiciones comunes que se utilizan frecuentemente al automatizar navegadores web. A continuación se enumeran
los nombres de cada uno. La vinculación de Selenium con Python proporciona algunosmétodos de convenienciaasí que no tienes que codificar un
clase expected_condition tú mismo o crea tu propio paquete de utilidades para ellos.
title_is
• el_título_contiene

presencia_del_elemento_localizado
visibilidad_de_elemento_ubicado
visibilidad_de
presencia_de_todos_los_elementos_ubicados

texto_a_presentar_en_el_elemento
• texto_a_estar_present_en_el_valor_del_elemento

• marco_disponible_y_cambiar_a_él
invisible_del_elemento_localizado
elemento_a_ser_hacible
vencimiento de
• elemento_a_ser_seleccionado
• elemento_ubicado_para_ser_seleccionado

• estado_de_selección_de_elemento_para_ser

estado_de_selección_elemento_localizado_a_ser

alerta_está_presente

[Link].supportimportcondiciones_esperadascomoCE

WebDriverWait(driver,10)
[Link](EC.elemento_a_ser_clicable(([Link],'someid')))

El módulo expected_conditions contiene un conjunto de condiciones predefinidas para usar con WebDriverWait.

Esperas implícitas

Una espera implícita le dice a WebDriver que sondee el DOM durante un cierto período de tiempo al intentar encontrar cualquier elemento (o
elementos) no disponibles de inmediato. La configuración predeterminada es 0. Una vez configurada, la espera implícita se establece por la duración de la
Objeto WebDriver.

fromseleniumimportcontrolador de navegador

driver=[Link]()
driver.implicitamente_esperar(10)segundos

24 Capítulo 5. Esperas
 Vínculos de Python para Selenium, Release 2

[Link]("[Link]
miElementoDinámico=driver.encontrar_elemento_por_id("miElementoDinámico")

5.2. Esperas Implícitas 25

Vínculos de Selenium Python, versión 2

26 Capítulo 5. Esperas
 CAPÍTULO 6

Objetos de Página

Este capítulo es una introducción tutorial al patrón de diseño de objetos de página. Un objeto de página representa un área en la web.
interfaz de usuario de la aplicación con la que su prueba está interactuando.

Beneficios de usar el patrón de objeto de página:

• Crear código reutilizable que se pueda compartir entre múltiples casos de prueba

Reducir la cantidad de código duplicado

Si la interfaz de usuario cambia, la corrección necesita cambios en un solo lugar

Caso de prueba

Aquí hay un caso de prueba que busca una palabra en el sitio web [Link] y asegura que se encuentren algunos resultados.

importar unidad de prueba

fromseleniumimportwebdriver
importar página

clasePythonOrgBuscar([Link]):
Una clase de prueba de muestra para mostrar cómo funciona el objeto de página

defconfigurarse(self):
[Link]=[Link]()
[Link]("[Link]

defprueba_buscar_en_python_org(self):
"""
Pruebas de la función de búsqueda de [Link]. Busca la palabra "pycon" y luego verifica.
˓→ que aparezcan algunos resultados.
Tenga en cuenta que no busca ningún texto en particular en la página de resultados de búsqueda.
˓→ Esta prueba verifica que
los resultados no estaban vacíos.
"""

27
Vínculos de Selenium para Python, Liberación 2

Cargar la página principal. En este caso, la página de inicio de [Link].

[Link]([Link])
Verifica si la palabra "Python" está en el título
afirmarmain_page.is_title_matches(),"el título de [Link] no coincide."
Establece el texto del cuadro de búsqueda a "pycon"
pycon
main_page.haz_clic_en_el_botón_ir()
[Link]([Link])
#Verifica que la página de resultados no esté vacía
afirmarNo se encontraron resultados.

deftearDown(self):
[Link]()

si__main__
[Link]()

Clases de objetos de página

El patrón de objeto de página tiene la intención de crear un objeto para cada página web. Al seguir esta técnica, se establece una capa de separación.
entre el código de prueba y la implementación técnica se crea.
[Link]á así:
del elemento importarElementoBasePagina
fromlocatorsimportLocalizadoresDePaginaPrincipal

elementoTextoDeBúsquedaDeClaseElementoDePaginaBase
Esta clase obtiene el texto de búsqueda del localizador especificado

El localizador para el cuadro de búsqueda donde se ingresa la cadena de búsqueda

q

claseBasePágina(objeto)
Clase base para inicializar la página base que será llamada desde todas las páginas

def__init__(self, controlador):
[Link]=controlador

clasePáginaPrincipalPáginaBase
Los métodos de acción de la página de inicio vienen aquí. Es decir, [Link]

#Declara una variable que contendrá el texto recuperado

ElementoDeTextoDeBúsqueda()

defis_title_matches(self):
Verifica que el texto codificado 'Python' aparezca en el título de la página
regresarPythonen sí mismotítulo del controlador

defhacer_clic_en_el_boton_ir(self):
Inicia la búsqueda
element=[Link].find_element( [Link]ÓN_GO)
*
[Link]()

28 Capítulo 6. Objetos de Página

 Enlaces de Selenium para Python, Versión 2

paginaResultadosDeBusquedaPorClase(PáginaBase):
Los métodos de acción de la página de resultados de búsqueda vienen aquí

defhay_resultados_encontrados
# Probablemente debería buscar este texto en la página específica
# elemento, pero por ahora funciona bien
devolverNo se encontraron [Link] en sí [Link].page_source

Elementos de la página

[Link] verá así:

[Link]

elementoBaseDeClase(objeto):
Clase base de página que se inicializa en cada clase de objeto de página.

defdefinir__(self, obj, valor):

Establece el texto al valor suministrado
[Link]
WebDriverWait(controlador,100).hasta(
lambdadriver: driver.find_element_by_name([Link])
driver.find_element_by_name([Link]).send_keys(valor)

defself, obj, owner

Obtiene el texto del objeto especificado
driver=[Link]
WebDriverWait(driver,100).until(
lambdadriver: driver.find_element_by_name([Link])
element = driver.find_element_by_name([Link])
volverelemento.obtener_atributo("valor")

Localizadores

Una de las prácticas es separar las cadenas de localización del lugar donde se están utilizando. En este ejemplo,
los localizadores de la misma página pertenecen a la misma clase.

El archivo [Link] se verá así:

[Link]

classMainPageLocators(objeto)
Una clase para los localizadores de la página principal. Todos los localizadores de la página principal deberían venir aquí

([Link],'submit')

localizadoresPaginaResultadosBusquedaClase(objeto):
Una clase para localizadores de resultados de búsqueda. Todos los localizadores de resultados de búsqueda deben venir

˓→ aquí
pasar

6.3. Elementos de la página 29

Bindings de Selenium para Python, Lanzamiento 2

30 Capítulo 6. Objetos de Página

 CAPÍTULO 7

API de WebDriver

Nota: Esta no es una documentación oficial. La documentación oficial de la API está disponibleaquí.

Este capítulo cubre todas las interfaces de Selenium WebDriver.

Estilo de importación recomendado

Las definiciones de la API en este capítulo muestran la ubicación absoluta de las clases. Sin embargo, el estilo de importación recomendado es
como se indica a continuación:

fromseleniumimportcontrolador de web

Entonces, puedes acceder a las clases de esta manera:

[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]

La clase de teclas especiales (Keys) se puede importar de la siguiente manera:

from [Link] importClaves

Las clases de excepción se pueden importar de esta manera (Reemplace TheNameOfTheExceptionClass con la clase real)
nombre dado a continuación):

31
Vínculos de Selenium para Python, Versión 2

de [Link] importar[ElNombreDeLaClaseDeExcepción]

Convenciones utilizadas en la API

Algunos atributos son llamables (o métodos) y otros no son llamables (propiedades). Todos los atributos llamables están terminando
con paréntesis redondos.

Aquí hay un ejemplo para propiedad:

url_actual
URL de la página cargada actualmente.

Uso:

driver.url_actual

Aquí hay un ejemplo de un método:

• cerrar()
Cierra la ventana actual.
Uso:

[Link]()

Excepciones
Excepciones que pueden ocurrir en todo el código del controlador de WebDriver.

[Link]
screen=None,
pila-
Ninguno
Bases:[Link]
Se lanza cuando un elemento está presente en el DOM pero las interacciones con ese elemento impactarán a otro elemento.
orden de pintura
[Link](msg=None,
Ninguna
pila-
trace=None)
Bases:[Link]
Lanzado al intentar seleccionar un elemento no seleccionable.

Por ejemplo, seleccionando un elemento 'script'.

[Link](msg=None,
ninguno
None
Bases:[Link]
Se lanza cuando un elemento está presente en el DOM, pero no es visible, por lo que no se puede interactuar con él.
Se encuentra más comúnmente al intentar hacer clic o leer el texto de un elemento que está oculto a la vista.

32 Capítulo 7. API de WebDriver

 Vínculos de Selenium para Python, versión 2

[Link](respuesta,msg)
Bases:[Link]
Se lanza cuando ha ocurrido un error en el lado del servidor.

Esto puede suceder al comunicarse con la extensión de firefox o el servidor de control remoto.
[Link](msg=None,
screen=None,
pila
traza=None)
Bases:[Link]
Se lanza cuando ha fallado la activación de un motor IME.

[Link]
screen=None,stack-
trazar=None)
Bases:[Link]
Se lanza cuando el soporte de IME no está disponible. Esta excepción se lanza para cada llamada de método relacionada con IME si IME
el soporte no está disponible en la máquina.
[Link](msg=None,
screen=None,stack-
trace=None)
Bases:[Link]
Los argumentos pasados a un comando son inválidos o están mal formados.
[Link](msg=None,
screen=None,
pila
trace=None)
Bases:[Link]
Se lanza al intentar agregar una cookie bajo un dominio diferente al de la URL actual.
[Link](msg=None,
screen=None,
pila
trace=None)
Bases:[Link]
excepción [Link](msg=None,
screen=None,stack-
Ninguno
Bases:[Link]
Se lanza cuando el selector que se utiliza para encontrar un elemento no devuelve un WebElement. Actualmente, esto solo
sucede cuando el selector es una expresión xpath y es sintácticamente inválida (es decir, no es un xpath
la expresión) o la expresión no selecciona WebElements (por ejemplo, “count(//input)”).
[Link](msg=None,
screen=None,
pila
traza=None)
Bases:[Link]
Se lanza cuando el marco o la ventana objetivo a la que se desea cambiar no existe.

7.1. Excepciones 33
Vínculos de Selenium para Python, Liberación 2

[Link](msg=None,
screen=None,
pila
trace=None)
Bases:[Link]
Se lanza cuando el objetivo proporcionado al método ActionsChainsmove() es inválido, es decir, fuera del documento.

[Link](msg=None,
screen=None, pila
trace=None)
Bases:[Link]
Se produce al cambiar a una alerta no presentada.
Esto puede ser causado por llamar a una operación en la clase Alert() cuando una alerta aún no está en la pantalla.

[Link](msg=None,
screen=None,stack-
trace=None)
Bases:[Link]
Se lanza cuando no se pudo encontrar el atributo del elemento.
Puede que desee verificar si el atributo existe en el navegador particular contra el que está probando. Algunos navegadores
pueden tener diferentes nombres de propiedades para la misma propiedad. (IE8 .innerText vs. Firefox .textContent)

[Link](msg=None,
screen=None, pila
trace=None)
Bases:[Link]
Lanzado cuando no se pudo encontrar el elemento.

Si encuentras esta excepción, es posible que desees verificar lo siguiente:

• Verifique su selector utilizado en su find_by...
• El elemento puede que aún no esté en la pantalla en el momento de la operación de búsqueda, (la página web aún se está cargando)
ve [Link]() para cómo escribir un envoltorio de espera para esperar un
elemento para aparecer.

[Link](msg=None,screen=None,
Ninguno
Bases:[Link]
Se lanza cuando el marco objetivo a cambiar no existe.
[Link](msg=None,screen=None,
Ninguno
Bases:[Link]
Se lanza cuando la ventana a la que se desea cambiar no existe.
Para encontrar el conjunto actual de identificadores de ventanas activas, puedes obtener una lista de los identificadores de ventanas activas de la siguiente manera

manera

printdriver.window_handles

[Link](msg=None,
screen=None,
pila
trace=None)
Bases:[Link]

34 Capítulo 7. API de WebDriver

 Vínculos de Selenium para Python, Versión 2

[Link](msg=None,
screen=None,
pila
Ninguno
Bases:[Link]
Se lanza cuando una referencia a un elemento ahora está "obsoleta".

Obsoleto significa que el elemento ya no aparece en el DOM de la página.

Las posibles causas de StaleElementReferenceException incluyen, pero no se limitan a:
Ya no estás en la misma página, o la página puede haberse actualizado desde que se localizó el elemento.
• El elemento puede haber sido eliminado y vuelto a agregar a la pantalla, ya que estaba ubicado. Como un
elemento siendo reubicado. Esto puede suceder típicamente con un marco de javascript cuando los valores son
actualizado y el nodo se reconstruye.
• El elemento puede haber estado dentro de un iframe u otro contexto que fue actualizado.

[Link]
trace=None)
Bases:[Link]
Se lanza cuando un comando no se completa en el tiempo suficiente.

[Link] se puede establecer la excepción de cookie(msg=None,

screen=None,
Ninguno
Bases:[Link]
Se lanza cuando un controlador no logra establecer una cookie.

[Link](msg=None,
screen=None,
pila
Ninguno
alert_text=None)
Bases:[Link]
Se lanza cuando aparece una alerta inesperada.
Generalmente se levanta cuando un modal esperado está bloqueando al webdriver para ejecutar más comandos.
[Link](msg=None,
screen=None,
None
Bases:[Link]
Se lanza cuando una clase de soporte no obtuvo un elemento web esperado.

[Link](msg=None, screen=None,
Ninguno
Bases: [Link]
Excepción base de webdriver.

Cadenas de acción

La implementación de ActionChains,

7.2. Cadenas de Acción 35

Vínculos de Selenium para Python, Versión 2

clase [Link].action_chains.ActionChains(driver)
Bases: objeto
ActionChains son una forma de automatizar interacciones de bajo nivel, como movimientos del mouse, acciones de botones del mouse,
presionar tecla y interacciones del menú contextual. Esto es útil para realizar acciones más complejas como pasar el mouse por encima y
arrastrar y soltar.

Generar acciones de usuario. Cuando llamas a métodos para acciones sobre el objeto ActionChains, las acciones se almacenan.
en una cola en el objeto ActionChains. Cuando llamas a perform(), los eventos se disparan en el orden en que están
en cola.
ActionChains se pueden utilizar en un patrón de cadena:

menu=driver.find_element_by_css_selector(".nav")
driver.find_element_by_css_selector(".nav #submenu1")

ActionChains(driver).mover_a_elemento(menu).clic(hidden_submenu).realizar()

O las acciones se pueden encolar una por una, y luego realizarse.

menu=driver.find_element_by_css_selector(".nav")
driver.find_element_by_css_selector(".nav #submenu1")

acciones=ActionChains(driver)
acciones.mover_a_elemento(menu)
acciones.hacer_clic(submenú_oculto)
[Link]()

De cualquier manera, las acciones se realizan en el orden en que son llamadas, una tras otra.
clic(en_elemento=None)
Hace clic en un elemento.

Args
El elemento para hacer clic. Si es None, hace clic en la posición actual del mouse.
hacer_clic_y_mantener(sobre_elemento=None)
Mantiene presionado el botón izquierdo del ratón sobre un elemento.

Args
El elemento sobre el que hacer clic. Si es None, hace clic en la posición actual del mouse.
clic derecho(en_elemento=None)
Realiza un clic de contexto (clic derecho) en un elemento.
Args
El elemento para hacer clic con el botón derecho. Si None, hace clic en la posición actual del ratón.

doble_click(elemento=None)
Hace doble clic en un elemento.

Args
El elemento a hacer doble clic. Si es None, hace clic en la posición actual del mouse.
arrastrar_y_soltar
Mantiene presionado el botón izquierdo del mouse en el elemento de origen, luego se mueve al elemento de destino y lo suelta
el botón del ratón.

Argumentos

36 Capítulo 7. API de WebDriver

 Vínculos de Selenium para Python, Liberación 2

• fuente: El elemento al que se hace clic con el ratón.

El elemento para soltar el ratón.

arrastrar_y_soltar_por_desplazamiento(origen,xdesplazamiento,ydesplazamiento)
Sostiene el botón izquierdo del ratón en el elemento fuente, luego se mueve al desplazamiento objetivo y lo suelta
el botón del ratón.

Args
• fuente: El elemento a presionar con el mouse.

• xoffset: Desplazamiento X al que mover.

• yoffset: Desplazamiento Y al que moverse.

tecla_abajo(valor, elemento=None)
Envía una pulsación de tecla solamente, sin soltarla. Solo debe usarse con teclas modificadoras (Control, Alt y
Cambio).

Args
La clave modificadora para enviar. Los valores se definen en la clase Keys.

• elemento: El elemento para enviar teclas. Si es None, envía una tecla al elemento actualmente enfocado.

Ejemplo, presionando ctrl+c:

ActionChains(driver).key_down([Link]).send_keys('c').key_up(Keys.
˓→ CONTROL).realizar()

tecla_arriba(valor, elemento=None)
Libera una tecla modificadora.

Args
La tecla modificadora para enviar. Los valores están definidos en la clase Keys.

• elemento: El elemento para enviar teclas. Si es None, envía una tecla al elemento actualmente enfocado.

Ejemplo, pulsando ctrl+c:

ActionChains(driver).key_down([Link]).send_keys('c').key_up(Keys.
˓→ CONTROL).realizar()

mover_por_desplazamiento(xoffset, yoffset)
Mover el ratón a un desfase desde la posición actual del ratón.
Argumentos
• xoffset: Desplazamiento X al que moverse, como un entero positivo o negativo.

• yoffset: desplazamiento en Y al que moverse, como un entero positivo o negativo.

mover_a_elemento(elemento_destino)
Moviendo el ratón al medio de un elemento.
Args
El WebElement al que mover.
mover_a_elemento_con_desplazamiento(hacia_elemento,xoffset,yoffset)

7.2. Cadenas de Acción 37

Enlaces de Selenium para Python, Versión 2

Mueva el mouse por un desplazamiento del elemento especificado. Los desplazamientos son relativos a la esquina superior izquierda del
elemento.

Argumentos
El WebElement al que moverse.
• xoffset: Desplazamiento X al que moverse.

• yoffset: Desplazamiento Y al que mover.

realizar()
Realiza todas las acciones almacenadas.

liberar(en_elemento=None)
Soltando un botón del ratón mantenido sobre un elemento.

Args
El elemento para soltar el ratón. Si es None, se suelta en la posición actual del ratón.
reiniciar_acciones()
Elimina las acciones que ya están almacenadas en el extremo remoto.

enviar_teclas(*claves_a_enviar)
Envía teclas al elemento actualmente enfocado.

Args
Las teclas a enviar. Las constantes de teclas modificadoras se pueden encontrar en la clase ‘Keys’.
enviar_claves_a_elemento(elemento, *claves_a_enviar)
Envía teclas a un elemento.
Args
El elemento al que enviar claves.
Las teclas para enviar. Las constantes de teclas modificadoras se pueden encontrar en la clase 'Keys'.

Alertas

La implementación de Alert.
[Link](controlador)
Bases: objeto
Permite trabajar con alertas.
Utiliza esta clase para interactuar con los mensajes de alerta. Contiene métodos para descartar, aceptar, introducir y obtener
texto de advertencias.
Aceptar / Descartar mensajes de alerta:

Alerta(driver).aceptar()
Alert(driver).dismiss()

Introduciendo un valor en un aviso de alerta:

nombre_solicitud = Alerta(controlador)name_prompt.send_keys("Willian Shakesphere

name_prompt.aceptar()
Leyendo el texto de un aviso para verificación:

38 Capítulo 7. API de WebDriver

 Vínculos de Selenium para Python, Release 2

¿Desea salir?
aceptar()
Acepta la alerta disponible.
Uso:: Alert(driver).accept() # Confirmar un cuadro de diálogo de alerta.

autenticar
Envía el nombre de usuario / contraseña a un diálogo Autenticado (como con la Autenticación HTTP Básica). Implicitamente 'hace clic
ok
Uso:: driver.switch_to.[Link]('queso', 'GoudaSecreto')
cadena que se establecerá en la sección de nombre de usuario del diálogo
establecer en la sección de contraseña del diálogo

despedir()
Descarta la alerta disponible.
enviar_claves(clavesPorEnviar)
Enviar teclas a la alerta.
Args
El texto que se enviará a Alert.
texto
Obtiene el texto de la Alerta.

Teclas Especiales

La implementación de las claves.

[Link]
Bases: objeto
Conjunto de códigos de teclas especiales.

u'\ue025'
u’ ’
u'\ue015'
u'\ue012'
u’\ue014’
u’\ue013’
u'\ue003'
u’\ue003’
u'1'
005
u'\ue03d'
CONTROL
028
u’017’

7.4. Teclas Especiales 39

Selenium Python Bindings, Versión 2

u'\ue015'
FIN= u’ ’
ENTER= u’\ue007’
u’e019’
u'\ue00c'
u’0’
F10= u'\ue03a'
e03b
F12= u''
F2= u’ 032’
F3= u’\ue033’
F4= u'\ue034'

u’\ue036’
F7= u’\ue037’
F8= u’\ue038’
F9= u’\ue039’

u’\ue011’
INSERT= u’ e016’

LEFT_ALT
'\ue009'

03d
u’ 024’
NULL= u’’
u'\ue01a'
u'\ue01b'
u’\ue01c’
01d
NUMPAD4
u'\ue01f'
u'\ue020'
u'\ue021'

40 Capítulo 7. API de WebDriver

 Vínculos de Selenium para Python, Liberación 2

'\ue022'
\ue023
00f
e00e
u'
'
u'\ue006'
\ue014
u’ 018’
u’ 4a3’
u’\ue008’
SPACE
u’e027’
[2~
UP= u’\ue013’

Localizar elementos por

Estos son los atributos que se pueden utilizar para localizar elementos. Ver laUbicando Elementoscapítulo de ejemplos de usos.
La implementación de By.
[Link]
Bases: objeto
Conjunto de estrategias de localización compatibles.

nombre de clase
selector css
id
texto del enlace
nombre
texto de enlace parcial
nombre de la etiqueta
xpath

Capacidades Deseadas

Ver elUsando Selenium con WebDriver remotosección de ejemplos de usos de capacidades deseadas. Las deseadas
Implementación de capacidades.
class [Link].desired_capabilities.DesiredCapabilities
Bases: objeto
Conjunto de capacidades deseadas predeterminadas compatibles.

7.5. Localizar elementos por 41

Enlaces de Python de Selenium, Lanzamiento 2

Utiliza esto como punto de partida para crear un objeto de capacidades deseadas para solicitar controladores web remotos para con-
Conectando al servidor de selenium o a la cuadrícula de selenium.

Ejemplo de uso:

fromseleniumimportcontrolador de navegador

[Link]

Crea un objeto de capacidades deseadas como punto de partida.

capabilidades=[Link]()
WINDOWS
10

Instanciar una instancia de Remote WebDriver con las capacidades deseadas.

driver=[Link](capacidades_deseadas=capacidades,
command_executor=selenium_grid_url

Nota: Siempre usa '.copy()' en el objeto DesiredCapabilities para evitar los efectos secundarios de alterar el Global.
instancia de clase.

ANDROID= {‘platform’: ‘ANDROID’, ‘browserName’: ‘android’, ‘version’: ‘’}

CHROME= {‘platform’: ‘ANY’, ‘browserName’: ‘chrome’, ‘version’: ‘’}
EDGE= {‘platform’: ‘WINDOWS’, ‘browserName’: ‘MicrosoftEdge’, ‘version’: ‘’}
FIREFOX= {‘acceptInsecureCerts’: True, ‘browserName’: ‘firefox’, ‘marionette’: True}
HTMLUNIT= {‘platform’: ‘ANY’, ‘browserName’: ‘htmlunit’, ‘version’: ‘’}
HTMLUNITWITHJS= {‘platform’: ‘ANY’, ‘browserName’: ‘htmlunit’, ‘version’: ‘firefox’, ‘javascriptEnabled’: True}
INTERNETEXPLORER= {‘platform’: ‘WINDOWS’, ‘browserName’: ‘internet explorer’, ‘version’: ‘’}
IPAD= {‘platform’: ‘MAC’, ‘browserName’: ‘iPad’, ‘version’: ‘’}
IPHONE= {‘platform’: ‘MAC’, ‘browserName’: ‘iPhone’, ‘version’: ‘’}
OPERA= {‘platform’: ‘ANY’, ‘browserName’: ‘opera’, ‘version’: ‘’}
PHANTOMJS= {‘platform’: ‘ANY’, ‘browserName’: ‘phantomjs’, ‘version’: ‘’, ‘javascriptEnabled’: True}
SAFARI= {‘platform’: ‘MAC’, ‘browserName’: ‘safari’, ‘version’: ‘’}

Servicios públicos
Los métodos de Utils.
[Link].find_connectable_ip(anfitrión, puerto=None)
Resolver un nombre de host a una IP, prefiriendo direcciones IPv4.

Preferimos IPv4 para no cambiar el comportamiento de implementaciones anteriores solo de IPv4, y porque algunos
los controladores (por ejemplo, FirefoxDriver) no soportan conexiones IPv6.

Si se proporciona el número de puerto opcional, solo se consideran las IP que escuchan en el puerto dado.

Args
• anfitrión - Un nombre de host.

• puerto - Número de puerto opcional.

42 Capítulo 7. API de WebDriver

 Vínculos de Selenium para Python, Lanzamiento 2

Devuelve una sola dirección IP, como una cadena. Si se encuentra alguna dirección IPv4, se devuelve una. De lo contrario, si
si se encuentra alguna dirección IPv6, se devuelve una. Si no, se devuelve None.
[Link].free_port()
Determina un puerto libre utilizando sockets.

[Link].is_connectable(puerto, host='localhost')
Intenta conectarse al servidor en el puerto para ver si está en funcionamiento.

Args
El puerto para conectarse.
[Link].is_url_connectable(puerto)
Intenta conectarse al servidor HTTP en la ruta /status y el puerto especificado para ver si responde con éxito.
Args
El puerto al que conectarse.
[Link].join_host_port(host, puerto)
Une un nombre de host y un puerto.
Esta es una implementación mínima destinada a manejar literales IPv6. Por ejemplo, _join_host_port('::1', 80)
'[::1]:80'.
Args
• host - Un nombre de host.

• puerto - Un puerto entero.

[Link].keys_to_typing(valor)
Procesa los valores que se introducirán en el elemento.

Firefox WebDriver

[Link](firefox_profile=None, fuego
fox_binary=None, timeout=30,
capabilities=None,proxy=None,
geckodriver
firefox_options=None,
[Link]
Bases:[Link]
context(*args,**kwds)
Establece el contexto en el que se están ejecutando los comandos de Selenium utilizando una declaración con. El estado del contexto
en el servidor se guarda antes de entrar en el bloque y se restaura al salir de él.
Parámetros contexto - El contexto puede ser una de las propiedades de la clase CONTEXT_CHROME o
CONTENIDO_DEL_CONTEXTO.
Ejemplo de uso:

[Link](selenium.CONTEXT_CHROME):
# ámbito de chrome
...hacer cosas...

salir()
Cierra el controlador y cierra todas las ventanas asociadas.

7.8. Firefox WebDriver 43

Vínculos de Selenium para Python, Lanzamiento 2

establecer_contexto(contexto)
chrome
contenido
Verdadero
perfil_de_firefox

Chrome WebDriver

[Link](executable_path='chromedriver',
port=0, chrome_options=None,
ninguno de-
Ninguna ser
vice_log_path=None)
Bases:[Link]
Controla el ChromeDriver y te permite manejar el navegador.
Necesitarás descargar el ejecutable de ChromeDriver desde[Link]
[Link]
crear_opciones()
iniciar_aplicación(id)
Lanza la aplicación de Chrome especificada por id.

salir()
Cierra el navegador y apaga el ejecutable de ChromeDriver que se inicia al comenzar la
ChromeDriver

WebDriver Remoto

La implementación de WebDriver.
[Link](command_executor=’[Link]
desired_capabilities=None,
None
Ninguno keep_alive=False,
file_detector=None)
Bases: objeto
Controla un navegador enviando comandos a un servidor remoto. Se espera que este servidor esté ejecutando el Web-
Protocolo de cable de controlador según lo definido en[Link]

Atributos
ID de sesión de la ventana del navegador iniciada y controlada por este WebDriver.
Diccionario de capacidades efectivas de esta sesión del navegador según se devuelve
por el servidor remoto. VerNo se puede traducir una URL.
CapacidadesDeseadas
• command_executor - objeto remote_connection.RemoteConnection utilizado para ejecutar com-
mandatos.
• error_handler - objeto [Link] utilizado para manejar errores.

44 Capítulo 7. API de WebDriver

 Vínculos de Selenium para Python, versión 2

agregar_cookie(cookie_dict)
Añade una cookie a tu sesión actual.
Args
Un objeto diccionario, con claves requeridas - “nombre” y “valor”; opcional
keys - “path”, “domain”, “secure”, “expiry”

Uso:driver.add_cookie({'name' : 'foo', 'value' : 'bar'}) driver.add_cookie({'name' : 'foo', 'value' :

‘bar’, ‘ruta’ : ‘/’}) controlador.agregar_cookie({‘nombre’ : ‘foo’, ‘valor’ : ‘bar’, ‘ruta’ : ‘/’, ‘seguro’:True})

volver()
Regresa un paso en el historial del navegador.
[Link]()
cerrar()
Cierra la ventana actual.
[Link]()
crear_elemento_web(element_id)
Crea un elemento web con el elemento_id especificado.
eliminar_todos_los_cookies()
Elimina todas las cookies en el ámbito de la sesión.
Usagedriver.eliminar_todas_las_galletas()

eliminar_cookie(nombre)
Elimina una sola cookie con el nombre dado.
Usagedriver.eliminar_cookie('my_cookie')
ejecutar(driver_command, params=None)
Envía un comando para ser ejecutado por un [Link].

Args
El nombre del comando a ejecutar como una cadena.
• params: Un diccionario de parámetros nombrados para enviar con el comando.
La respuesta JSON del comando cargada en un objeto diccionario.
ejecutar_script_async(script, *args)
Ejecuta JavaScript de manera asíncrona en la ventana/máscara actual.
Args
• script: El JavaScript a ejecutar.
• *args: Cualquier argumento aplicable para tu JavaScript.
Usagedriver.execute_async_script('[Link]')
ejecutar_script(script,*args)
Ejecuta JavaScript de manera sincrónica en la ventana/marca actual.
Args
El JavaScript a ejecutar.
• *args: Cualquier argumento aplicable para tu JavaScript.
Usagedriver.execute_script('[Link]')

7.10. WebDriver remoto 45

Selenium Python Bindings, Versión 2

file_detector_context(*args,**kwds)
Sobrescribe el detector de archivos actual (si es necesario) en un contexto limitado. Asegura que el detector de archivos original esté configurado.
después.
Ejemplo:
con webdriver.file_detector_context(UselessFileDetector): someinput.send_keys('/etc/hosts')

Args
•file_detector_class - Clase del detector de archivos deseado. Si la clase es diferente de
el actual file_detector, luego la clase se instancia con args y kwargs y se utiliza como
un detector de archivos durante la duración del administrador de contexto.

•args - Argumentos opcionales que se pasan a la clase del detector de archivos durante
instanciación.
• kwargs - Argumentos de palabra clave, pasados de la misma manera que args.

encontrar_elemento(por='id', valor=None)
Método 'privado' utilizado por los métodos find_element_by_*.

UsoUtiliza el correspondiente find_element_by_* en lugar de esto.

Tipo de retornoWebElemento

encontrar_elemento_por_nombre_de_clase(nombre)
Encuentra un elemento por nombre de clase.

Args
• nombre: El nombre de la clase del elemento a encontrar.

Usagedriver.encontrar_elemento_por_clase('foo')
encontrar_elemento_por_selector_css(css_selector)
Encuentra un elemento por selector css.

Args
El selector css que se utilizará para encontrar elementos.
Usagedriver.encontrar_elemento_por_selector_css('#foo')

encontrar_elemento_por_id(id_)
Encuentra un elemento por id.

Argumentos
• id_ - El id del elemento que debe ser encontrado.

Usagedriver.encontrar_elemento_por_id('foo')

encontrar_elemento_por_texto_de_enlace(link_text)
Encuentra un elemento por el texto del enlace.

Args
El texto del elemento que debe ser encontrado.
Usagedriver.encontrar_elemento_por_texto_de_enlace('Iniciar sesión')

encontrar_elemento_por_nombre(nombre)
Encuentra un elemento por nombre.

Args

46 Capítulo 7. API de WebDriver

 Vínculos de Selenium para Python, Lanzamiento 2

El nombre del elemento a encontrar.

Usagedriver.encontrar_elemento_por_nombre('foo')

encontrar_elemento_por_texto_de_enlace_parcial(link_text)
Encuentra un elemento mediante una coincidencia parcial de su texto de enlace.

Args
El texto del elemento para hacer una coincidencia parcial.
Usagedriver.encontrar_elemento_por_texto_de_enlace_parcial('Sign')

encontrar_elemento_por_nombre_de_etiqueta(nombre)
Encuentra un elemento por nombre de etiqueta.

Args
El nombre de la etiqueta del elemento a encontrar.
Usagedriver.encontrar_elemento_por_nombre_de_etiqueta(‘foo’)

encontrar_elemento_por_xpath(xpath)
Encuentra un elemento por xpath.

Args
• xpath - El localizador xpath del elemento a encontrar.
Usagedriver.encontrar_elemento_por_xpath('//div/td[1]')

find_elements(by='id', value=None)
Método 'privado' utilizado por los métodos find_elements_by_*.
Uso: Utilice los correspondientes find_elements_by_* en lugar de esto.

Tipo de retorno lista de WebElement

encontrar_elementos_por_nombre_de_clase(nombre)
Encuentra elementos por nombre de clase.

Args
• nombre: El nombre de la clase de los elementos a encontrar.

Usagedriver.encontrar_elementos_por_nombre_clase('foo')

encontrar_elementos_por_selector_css(css_selector)
Encuentra elementos por selector CSS.

Argumentos
El selector css que se debe utilizar al encontrar elementos.
Usagedriver.encontrar_elementos_por_selector_css('.foo')

encontrar_elementos_por_id(id_)
Encuentra múltiples elementos por id.

Args
• id_ - El id de los elementos que se deben encontrar.

Usagedriver.encontrar_elementos_por_id('foo')

encontrar_elementos_por_texto_en_link(texto)
Encuentra elementos por texto de enlace.

Args

7.10. Controlador Web Remoto 47

Bindings de Selenium para Python, Versión 2

El texto de los elementos que se deben encontrar.

Usagedriver.encontrar_elementos_por_texto_link('Iniciar sesión')

encontrar_elementos_por_nombre(nombre)
Encuentra elementos por nombre.

Args
El nombre de los elementos a encontrar.
Usagedriver.encontrar_elementos_por_nombre('foo')

encontrar_elementos_por_texto_parcial_del_enlace(link_text)
Encuentra elementos por una coincidencia parcial de su texto de enlace.

Args
El texto del elemento para hacer una coincidencia parcial.
Usagedriver.encontrar_elemento_por_texto_de_enlace_parcial('Signo')

encontrar_elementos_por_nombre_de_etiqueta(nombre)
Encuentra elementos por nombre de etiqueta.

Args
• nombre: El nombre de la etiqueta que se usa al encontrar elementos.

Usagedriver.encontrar_elementos_por_nombre_de_etiqueta('foo')

encontrar_elementos_por_xpath(xpath)
Encuentra múltiples elementos por xpath.

Args
• xpath - El localizador xpath de los elementos a encontrar.
Usagedriver.encontrar_elementos_por_xpath("//div[contains(@class, 'foo')]" )

adelante()
Avanza un paso en el historial del navegador.
[Link]()
obtener(url)
Carga una página web en la sesión actual del navegador.

obtener_cookie(nombre)
Obtén una sola cookie por nombre. Devuelve la cookie si se encuentra, None si no.

Usagedriver.get_cookie('my_cookie')
obtener_galletas()
Devuelve un conjunto de diccionarios, correspondientes a las cookies visibles en la sesión actual.
Usagedriver.obtener_galletas()

obtener_registro(tipo_de_registro)
Obtiene el registro para un tipo de registro dado

Argumentos
tipo de registro que se devolverá
Usagedriver.get_log('navegador') driver.get_log('driver') driver.get_log('cliente')
driver.get_log('servidor')

48 Capítulo 7. API de WebDriver

 Vínculos de Selenium para Python, Lanzamiento 2

obtener_capture_como_base64()
Obtiene la captura de pantalla de la ventana actual como una cadena codificada en base64, lo cual es útil en incrustados.
imágenes en HTML.

Usagedriver.obtener_imagen_como_base64()

obtener_captura_de_pantalla_como_archivo(nombre_archivo)
Obtiene la captura de pantalla de la ventana actual. Devuelve False si hay algún IOError, de lo contrario, devuelve True.
Utiliza rutas completas en tu nombre de archivo.

Args
• nombre de archivo: La ruta completa donde deseas guardar tu captura de pantalla.

Usagedriver.get_screenshot_as_file(''/Screenshots/[Link]'')

obtener_captura_de_pantalla_como_png()
Obtiene la captura de pantalla de la ventana actual como datos binarios.

Usagedriver.obtener_capture_de_pantalla_como_png()

obtener_posición_ventana(manejadorVentana='actual')
Obtiene la posición x,y de la ventana actual.
Usagedriver.obtener_posición_ventana()

obtener_rectángulo_ventana()
Obtiene las coordenadas x, y de la ventana, así como la altura y el ancho de la ventana actual.
Usagedriver.get_window_rect()
obtener_tamaño_ventana(manejadorVentana='actual')
Obtiene el ancho y la altura de la ventana actual.
Usagedriver.get_window_size()
espera_implicita(tiempo_a_esperar)
Establece un tiempo de espera fijo para esperar implícitamente a que se encuentre un elemento o a que se complete un comando.
el método solo necesita ser llamado una vez por sesión. Para establecer el tiempo de espera para las llamadas a exe-
cute_async_script, vea set_script_timeout.

Args
Cantidad de tiempo a esperar (en segundos)
Usagedriver.esperar_implicito(30)

maximizar_ventana()
Maximiza la ventana actual que está utilizando el webdriver

salir()
Cierra el controlador y cierra todas las ventanas asociadas.

[Link]()
refrescar()
Actualiza la página actual.
[Link]()
guardar_captura_de_pantalla

7.10. WebDriver Remoto 49

Vínculos de Selenium para Python, Liberación 2

Obtiene la captura de pantalla de la ventana actual. Devuelve False si hay algún IOError, de lo contrario devuelve True.
Utiliza rutas completas en tu nombre de archivo.

Args
• nombre de archivo: La ruta completa donde deseas guardar tu captura de pantalla.

Usagedriver.guardar_imagen('/Screenshots/[Link]')

establecer_timeout_de_carga_de_página(tiempo_a_esperar)
Establezca la cantidad de tiempo a esperar para que una carga de página se complete antes de lanzar un error.

Args
El tiempo de espera
Usagedriver.set_page_load_timeout(30)

establecer_timeout_script
Establezca la cantidad de tiempo que el script debe esperar durante una llamada a execute_async_script antes de lanzar
ing un error.

Args
El tiempo a esperar (en segundos)
Usagedriver.set_script_timeout(30)

establecer_posición_ventana(x,y,manejadorVentana=’actual’)
Establece la posición x,y de la ventana actual. ([Link])
Argumentos
• x: la coordenada x en píxeles para establecer la posición de la ventana

• y: la coordenada y en píxeles para establecer la posición de la ventana

Usagedriver.establecer_posición_ventana(0,0)

set_window_rect(x=None,y=None,width=None,height=None)
Establece las coordenadas x, y de la ventana, así como la altura y el ancho de la ventana actual.
Usagedriver.set_window_rect(x=10, y=10) driver.set_window_rect(width=100, height=200)
driver.set_window_rect(x=10, y=10, ancho=100, alto=200)
establecer_tamaño_ventana(ancho, alto, manejadorVentana='actual')
Establece el ancho y la altura de la ventana actual. ([Link])
Args
• ancho: el ancho en píxeles para establecer la ventana en

• altura: la altura en píxeles para establecer la ventana

Usagedriver.set_window_size(800,600)
iniciar_cliente()
Se llama antes de iniciar una nueva sesión. Este método puede ser sobrescrito para definir un comportamiento de inicio personalizado.

iniciar_sesión
Crea una nueva sesión con las capacidades deseadas.
Args

50 Capítulo 7. API de WebDriver

 Selenium Python Bindings, Versión 2

El nombre del navegador a solicitar.

¿Qué versión del navegador solicitar?
¿Qué plataforma solicitar para el navegador?
Si la nueva sesión debe soportar JavaScript.
• perfil_de_navegador - Un objeto [Link].firefox_profile.FirefoxProfile. Solo
utilizado si se solicita Firefox.

detener_cliente()
Llamado después de ejecutar un comando de salida. Este método puede ser sobrescrito para definir un apagado personalizado.
comportamiento.
cambiar_a_elemento_activo()
Uso obsoleto de driver.switch_to.active_element
cambiar_a_alerta()
Uso obsoleto de driver.switch_to.alert
cambiar_a_contenido_predeterminado()
Uso obsoleto de driver.switch_to.default_content
cambiar_a_frame(referencia_frame)
Uso obsoleto de driver.switch_to.frame
cambiar_a_ventana(nombre_ventana)
Uso obsoleto de driver.switch_to.window
caché_de_aplicación
Devuelve un objeto ApplicationCache para interactuar con la caché de la aplicación del navegador

url_actual
Obtiene la URL de la página actual.
Usagedriver.url_actual
manejador_ventana_actual
Devuelve el identificador de la ventana actual.

Usagedriver.current_window_handle
capacidades_deseadas
devuelve las capacidades deseadas actuales del controlador que se están utilizando

detector_de_archivos
tipos_de_registro
Obtiene una lista de los tipos de registro disponibles

Tipos de registro de controlador de uso

móvil
nombre
Devuelve el nombre del navegador subyacente para esta instancia.
Uso
[Link]

orientación
Obtiene la orientación actual del dispositivo
orientación del conductor

7.10. WebDriver Remoto 51

Vínculos de Selenium Python, Lanzamiento 2

fuente_de_página
Obtiene el código fuente de la página actual.

Usagedriver.page_source
cambiar_a
título
Devuelve el título de la página actual.
Título del controlador de uso

manejadores_de_ventana
Devuelve los identificadores de todas las ventanas dentro de la sesión actual.

Usagedriver.window_handles

ElementoWeb

[Link](padre,id_,w3c=False)
Bases: objeto
Representa un elemento DOM.
En general, todas las operaciones interesantes que interactúan con un documento se realizarán a través de esta interfaz.
Todas las llamadas a métodos realizarán una verificación de frescura para asegurarse de que la referencia del elemento siga siendo válida. Esto es-

esencialmente determina si el elemento sigue o no adjunto al DOM. Si esta prueba falla, entonces un
Se lanza StaleElementReferenceException, y todas las llamadas futuras a esta instancia fallarán.

borrar()
Borra el texto si es un elemento de entrada de texto.

hacer clic()
Haz clic en el elemento.

encontrar_elemento(por='id', valor=None)
encontrar_elemento_por_nombre_de_clase(nombre)
Encuentra un elemento dentro de los hijos de este elemento por nombre de clase.

Argumentos
nombre - nombre de la clase para buscar.

encontrar_elemento_por_selector_css(css_selector)
Encuentra elementos dentro de los hijos de este elemento por selector CSS.

Argumentos
cadena de selector CSS, ej: '[Link]#home'
encontrar_elemento_por_id(id_)
Encuentra el elemento dentro de los hijos de este elemento por ID.

Args
• id_ - ID del elemento hijo a ubicar.
encontrar_elemento_por_texto_de_enlace(link_text)
Encuentra el elemento dentro de los hijos de este elemento por texto de enlace visible.

Argumentos

52 Capítulo 7. API de WebDriver

 Enlaces de Selenium para Python, Versión 2

Cadena de texto del enlace para buscar.

encontrar_elemento_por_nombre(nombre)
Encuentra el elemento dentro de los hijos de este elemento por nombre.

Argumentos
• nombre - propiedad nombre del elemento a encontrar.

encontrar_elemento_por_texto_parcial_del_enlace(link_text)
Encuentra el elemento dentro de los hijos de este elemento por texto de enlace parcialmente visible.

Args
Texto del enlace - Cadena de texto del enlace a buscar.

encontrar_elemento_por_nombre_de_etiqueta(nombre)
Encuentra un elemento dentro de los hijos de este elemento por nombre de etiqueta.

Args
nombre - nombre de la etiqueta html (por ejemplo: h1, a, span)

encontrar_elemento_por_xpath(xpath)
Encuentra el elemento por xpath.

Argsxpath - xpath del elemento a localizar. “//input[@class='myelement’]”

Nota: La ruta base será relativa a la ubicación de este elemento.
Esto seleccionará el primer enlace debajo de este elemento.

myelement.encontrar_elementos_por_xpath(".//a")

Sin embargo, esto seleccionará el primer enlace en la página.

myelement.encontrar_elementos_por_xpath("//a")

encontrar_elementos(por='id', valor=None)
encontrar_elementos_por_nombre_de_clase(nombre)
Encuentra una lista de elementos dentro de los hijos de este elemento por nombre de clase.

Argumentos
nombre - nombre de la clase a buscar.
encontrar_elementos_por_selector_css(css_selector)
Busca una lista de elementos dentro de los hijos de este elemento mediante un selector CSS.

Args
cadena de selector CSS, ej: '[Link]#home'
encontrar_elementos_por_id(id_)
Encuentra una lista de elementos dentro de los hijos de este elemento por ID.

Args
• id_ - Id del elemento hijo a encontrar.

encontrar_elementos_por_texto_en_el_enlace(link_text)
Encuentra una lista de elementos dentro de los hijos de este elemento por texto de enlace visible.

Args
Cadena de texto del enlace para buscar.

7.11. WebElement 53
Bindings de Selenium para Python, Lanzamiento 2

encontrar_elementos_por_nombre(nombre)
Encuentra una lista de elementos dentro de los hijos de este elemento por nombre.

Argumentos
nombre - propiedad de nombre para buscar.
encontrar_elementos_por_texto_parcial_del_enlace(link_text)
Encuentra una lista de elementos dentro de los hijos de este elemento por texto del enlace.

Args
Cadena de texto del enlace para buscar.
encontrar_elementos_por_nombre_de_etiqueta(nombre)
Encuentra una lista de elementos dentro de los hijos de este elemento por nombre de etiqueta.

Args
nombre - nombre de la etiqueta html (por ejemplo: h1, a, span)

encontrar_elementos_por_xpath(xpath)
Encuentra elementos dentro del elemento por xpath.

Args
• xpath - cadena de localizador xpath.

Nota: La ruta base será relativa a la ubicación de este elemento.

Esto seleccionará todos los enlaces bajo este elemento.

myelement.encontrar_elementos_por_xpath(".//a")

Sin embargo, esto seleccionará todos los enlaces en la página misma.

myelement.encontrar_elementos_por_xpath("//a")

obtener_atributo(nombre)
Obtiene el atributo o propiedad dada del elemento.
Este método intentará primero devolver el valor de una propiedad con el nombre dado. Si existe una propiedad con ese
el nombre no existe, devuelve el valor del atributo con el mismo nombre. Si no hay un atributo con eso
nombre, None es devuelto.

Los valores que se consideran verdaderos, es decir, iguales a "verdadero" o "falso", se devuelven como booleanos. Todos los demás
Los valores que no son None se devuelven como cadenas. Para atributos o propiedades que no existen, se devuelve None.
Args
Nombre del atributo / propiedad a recuperar.
Ejemplo:

Verifica si la clase CSS 'active' está aplicada a un elemento.

activoentarget_element.get_attribute("clase")

obtener_propiedad(nombre)
Obtiene la propiedad dada del elemento.
Argumentos
Nombre de la propiedad a recuperar.
Ejemplo:

54 Capítulo 7. API de WebDriver

 Vínculos de Selenium para Python, Versión 2

Verifica si la clase CSS "activo" está aplicada a un elemento.

longitud_texto=elemento_objetivo.obtener_propiedad("longitud_texto")

está_mostrado()
Si el elemento es visible para un usuario.
está_habilitado()
Devuelve si el elemento está habilitado.
está_seleccionado()
Devuelve si el elemento está seleccionado.
Se puede usar para verificar si una casilla de verificación o un botón de opción está seleccionado.

captura de pantalla(nombrefichero)
Obtiene la captura de pantalla del elemento actual. Devuelve False si hay algún IOError, de lo contrario devuelve True.
Utiliza rutas completas en tu nombre de archivo.

Argumentos
• nombre de archivo: La ruta completa donde deseas guardar tu captura de pantalla.

[Link](‘/Screenshots/[Link]’)

enviar_claves(*valor)
Simula escribir en el elemento.
Args
• valor - Una cadena para escribir o establecer campos de formularios. Para establecer entradas de archivos, esto podría ser un
ruta de archivo local.

Utiliza esto para enviar eventos de teclas simples o para completar campos de formulario:

driver.find_element_by_name('username')
form_textfield.send_keys("admin")

Esto también se puede utilizar para establecer entradas de archivo.

driver.find_element_by_name('profilePic')
file_input.send_keys("ruta/a/[Link]")
Generalmente es mejor envolver la ruta del archivo en uno de los métodos
# en [Link] para devolver la ruta real y soportar pruebas cruzadas en sistemas operativos.
# file_input.send_keys([Link]("ruta/a/imagen_de_perfil.gif"))

enviar()
Envía un formulario.

valor_de_propiedad_css(nombre_de_propiedad)
El valor de una propiedad CSS.
identificación
ID interno utilizado por selenium.
Esto es principalmente para uso interno. Casos de uso simples como verificar si 2 elementos web se refieren al mismo.
elemento, se puede hacer usando==:

sielemento1==elemento2:
Estos 2 son iguales

7.11. WebElement 55
Bindings de Selenium para Python, Versión 2

ubicación
La ubicación del elemento en el lienzo renderizable.
ubicación_una_vez_desplazada_a_la_vista
ESTA PROPIEDAD PUEDE CAMBIAR SIN PREVIO AVISO. Use esto para descubrir dónde en la pantalla un
el elemento es para que podamos hacer clic en él. Este método debería hacer que el elemento se desplace a la vista.

Devuelve la ubicación de la esquina superior izquierda en la pantalla, o None si el elemento no es visible.

padre
Referencia interna a la instancia de WebDriver de la cual se encontró este elemento.

recto
Un diccionario con el tamaño y la ubicación del elemento.
captura_de_pantalla_como_base64
Obtiene la captura de pantalla del elemento actual como una cadena codificada en base64.

element.screenshot_as_base64
captura_de_pantalla_como_png
Obtiene la captura de pantalla del elemento actual como datos binarios.

element.screenshot_as_png
tamaño
El tamaño del elemento.
nombre_de_etiqueta
La propiedad tagName de este elemento.

texto
El texto del elemento.

Soporte de interfaz de usuario

[Link](webelement)
Bases: objeto
deseleccionar_todo()
Borrar todas las entradas seleccionadas. Esto solo es válido cuando el SELECT admite múltiples selecciones. lanza
NotImplementedError Si el SELECT no admite selecciones múltiples
deseleccionar_por_indice(indice)
Deseleccione la opción en el índice dado. Esto se hace examinando el atributo "índice" de un elemento, y
no meramente contando.
Args
• índice - La opción en este índice será deseleccionada
lanza NoSuchElementException si no hay una opción con el índice especificado en SELECT
deseleccionar_por_valor(valor)
Deselecciona todas las opciones que tengan un valor que coincida con el argumento. Es decir, cuando se le dé 'foo' esto deselectaría
una opción como:
<option value=”foo”>Bar</option>

Args
El valor a coincidir

56 Capítulo 7. API de WebDriver

 Vínculos de Selenium para Python, Lanzamiento 2

lanza NoSuchElementException si no hay una opción con el valor especificado en SELECT

deseleccionar_por_texto_visible(texto)
Deselecciona todas las opciones que muestran texto que coincide con el argumento. Es decir, dado 'Bar', esto deseleccionaría
una opción como:
<option value=”foo”>Bar</option>
Argumentos
El texto visible para coincidir
seleccionar_por_indice(indice)
Seleccione la opción en el índice dado. Esto se hace examinando el atributo "índice" de un elemento, y no
simplemente contando.
Args
• índice - La opción en este índice será seleccionada
Lanza NoSuchElementException si no hay una opción con el índice especificado en SELECT
seleccionar_por_valor(valor)
Selecciona todas las opciones que tengan un valor que coincida con el argumento. Es decir, cuando se da 'foo', esto seleccionaría un
opción como:
<option value=”foo”>Bar</option>
Args
El valor para coincidir con
lanza NoSuchElementException si no hay una opción con el valor especificado en SELECT
seleccionar_por_texto_visible(texto)
Seleccione todas las opciones que muestren texto que coincida con el argumento. Es decir, cuando se proporciona 'Bar' esto seleccionaría un
opción como:
<option value=”foo”>Bar</option>

Args
El texto visible para hacer coincidir
lanza NoSuchElementException si no hay ninguna opción con el texto especificado en SELECT

todas_las_opciones_seleccionadas
Devuelve una lista de todas las opciones seleccionadas que pertenecen a esta etiqueta de selección

primera_opción_seleccionada
La primera opción seleccionada en esta etiqueta select (o la opción actualmente seleccionada en un select normal)

opciones
Devuelve una lista de todas las opciones que pertenecen a esta etiqueta de selección

[Link](driver,timeout,poll_frequency=0.5,
ignored_exceptions=None)
Bases: objeto
hasta(método, mensaje=’‘)
Llama al método proporcionado con el controlador como argumento hasta que el valor devuelto no sea Falso.

hasta_no(método,mensaje=’‘)
Llama al método proporcionado con el controlador como argumento hasta que el valor de retorno sea False.

7.12. Soporte de UI 57
Selenium Python Bindings, Lanzamiento 2

Soporte de color

[Link](rojo,verde,azul,alpha=1)
Bases: objeto
Clase de soporte para conversión de color

Ejemplo:
de [Link] importarColor

imprimir(Color.from_string('#00ff33').rgba)
imprimir(Color.from_string('rgb(1, 255, 3)').hex)
imprimir(Color.from_string('azul').rgba)

staticfrom_string(str_)
hex
rgb
rgba

Condiciones esperadas Soporte

[Link].expected_conditions.alert_is_present
Bases: objeto
Se espera que haya una alerta.
[Link].expected_conditions.element_located_selection_state_to_be(loc
es_
Bases: objeto
Una expectativa de localizar un elemento y verificar si el estado de selección especificado está en ese estado. El localizador es una tupla de
(por, ruta) is_selected es un booleano
[Link].expected_conditions.element_located_to_be_selected(localizador)
Bases:objeto
Se selecciona una expectativa para que el elemento sea ubicado. El localizador es una tupla de (por, ruta)

[Link].expected_conditions.element_selection_state_to_be(element,
is_selected)
Bases: objeto
Una expectativa para verificar si el elemento dado está seleccionado. El elemento es un objeto WebElement, is_selected es un
Boolean.
class [Link].expected_conditions.element_to_be_clickable(locator)
Bases: objeto
Una Expectativa para verificar que un elemento sea visible y esté habilitado de manera que se pueda hacer clic en él.

[Link].expected_conditions.element_to_be_selected(element)
Bases:objeto
Una expectativa para verificar que la selección esté seleccionada. El elemento es un objeto WebElement

58 Capítulo 7. API de WebDriver

 Vínculos de Selenium para Python, Lanzamiento 2

[Link].expected_conditions.frame_to_be_available_and_switch_to_it(lo
Bases: objeto
Una expectativa para verificar si el marco dado está disponible para cambiar. Si el marco está disponible, cambia.
el controlador dado al marco especificado.
[Link].expected_conditions.invisibilidad_del_elemento_localizado(locator)
Bases: objeto
Una expectativa para comprobar que un elemento es invisible o no está presente en el DOM.
localizador utilizado para encontrar el elemento

[Link].expected_conditions.nueva_ventana_ha_sido_abierta(current_handles)
Bases: objeto
Una expectativa de que se abrirá una nueva ventana y que aumentará el número de identificadores de ventanas.

[Link].expected_conditions.numero_de_ventanas_a_ser(num_windows)
Bases: objeto
Una expectativa de que el número de ventanas sea un valor determinado.
[Link].expected_conditions.presencia_de_todos_los_elementos_localizados(locator)
Bases: objeto
Una expectativa para comprobar que hay al menos un elemento presente en una página web. Se utiliza un localizador para encontrar el
el elemento devuelve la lista de WebElements una vez que han sido ubicados

[Link].expected_conditions.presencia_de_elemento_localizado(localizador)
Bases: objeto
Una expectativa para verificar que un elemento está presente en el DOM de una página. Esto no significa necesariamente
que el elemento es visible. localizador - utilizado para encontrar el elemento devuelve el WebElement una vez que se encuentra

[Link].expected_conditions.staleness_of(element)
Bases: objeto
Espera hasta que un elemento ya no esté adjunto al DOM. element es el elemento por el que esperar. devuelve Falso si el
el elemento todavía está adjunto al DOM, de lo contrario es verdadero.

[Link].expected_conditions.text_to_be_present_in_element(localizador,
text_
Bases: objeto
Una expectativa para verificar si el texto dado está presente en el elemento especificado. localizador, texto

[Link].expected_conditions.text_to_be_present_in_element_value(locato
texto_
Bases: objeto
Una expectativa para verificar si el texto dado está presente en el localizador del elemento, texto

class [Link].expected_conditions.title_contains(titulo)
Bases: objeto
Una expectativa para verificar que el título contenga una subcadena que distingue entre mayúsculas y minúsculas. title es el fragmento de título esperado
devuelve True cuando el título coincide, False en caso contrario

[Link].expected_conditions.titulo_es(title)
Bases: objeto
Una expectativa para verificar el título de una página. title es el título esperado, que debe ser una coincidencia exacta.
Verdadero si el título coincide, falso de lo contrario.

7.14. Condiciones esperadas Soporte 59

Bindings de Selenium para Python, Liberación 2

[Link].expected_conditions.visibilidad_de(elemento)
Bases: objeto
Una expectativa para verificar que un elemento, conocido por estar presente en el DOM de una página, es visible. Visibilidad
significa que el elemento no solo se muestra, sino que también tiene una altura y un ancho que son mayores que 0. el elemento es el
WebElement devuelve el (mismo) WebElement una vez que es visible
[Link].expected_conditions.visibilidad_de_todos_los_elementos_localizados(locator
Bases: objeto
Una expectativa para verificar que todos los elementos estén presentes en el DOM de una página y sean visibles. La visibilidad significa
que los elementos no solo se muestran, sino que también tienen una altura y un ancho que son mayores que 0. localizador - utilizado para
encontrar los elementos devuelve la lista de WebElements una vez que están localizados y visibles

[Link].expected_conditions.visibilidad_de_cualquier_elemento_localizado(locator
Bases: objeto
Una expectativa para verificar que hay al menos un elemento visible en una página web. Se utiliza un localizador para encontrar el
elemento devuelve la lista de WebElements una vez que se han localizado

[Link].expected_conditions.visibility_of_element_located(locator)
Bases: objeto
Una expectativa para verificar que un elemento está presente en el DOM de una página y visible. La visibilidad significa que
el elemento no solo se muestra sino que también tiene una altura y un ancho que son mayores que 0. localizador - utilizado para encontrar el
el elemento devuelve el WebElement una vez que se encuentra y es visible

60 Capítulo 7. API de WebDriver

 CAPÍTULO 8

Apéndice: Preguntas Frecuentes

Otra pregunta frecuente:No puedo acceder a URLs. Por favor, proporciona el texto que deseas traducir.

¿Cómo usar ChromeDriver?

Descargar la últimachromedriver de la página de descargasDescomprime el archivo:

descomprimir chromedriver_linux32_x.[Link]

Deberías ver achromedriverexecutable. Ahora puedes crear una instancia de Chrome WebDriver así:

controlador=[Link](ruta_ejecutable="/ruta/al/chromedriver")

El resto del ejemplo debería funcionar como se indica en otra documentación.

¿Selenium 2 soporta XPath 2.0?

Ref:[Link]
Selenium delega las consultas XPath al propio motor XPath del navegador, por lo que Selenium admite XPath.
cualquier cosa que el navegador soporte. En navegadores que no tienen motores XPath nativos (IE 6, 7, 8), Selenium soporta
Solo XPath 1.0.

¿Cómo desplazarse hacia abajo hasta el final de una página?

Ref:[Link]
Puedes usar el método execute_script para ejecutar JavaScript en la página cargada. Así que puedes llamar a la API de JavaScript.
desplazarse hasta la parte inferior o cualquier otra posición de una página.

61
Bindings de Selenium para Python, Versión 2

Aquí hay un ejemplo para desplazarse hasta el final de una página:

driver.execute_script("[Link](0, [Link]);")

Elventanael objeto en el DOM tiene undesplazar amétodo para desplazarse a cualquier posición de una ventana abierta. ElscrollHeight
es una propiedad común para todos los elementos. El [Link] dará la altura de todo el cuerpo del
página.

¿Cómo guardar archivos automáticamente utilizando un perfil personalizado de Firefox?

Ref:[Link]
Ref:[Link]
El primer paso es identificar el tipo de archivo que deseas guardar automáticamente.

Para identificar el tipo de contenido que deseas descargar automáticamente, puedes usarcurl:

curl-I URL|grep"Content-Type"

Otra forma de encontrar el tipo de contenido es utilizando elsolicitudesmódulo, puedes usarlo así:
importar solicitudes
content_type=[Link]('[Link]
imprimir(tipo_de_contenido)

Una vez que se identifica el tipo de contenido, puedes usarlo para establecer la preferencia del perfil de firefox: [Link].
[Link]
Aquí hay un ejemplo:

importos

fromseleniumimportcontrolador Web

fp=[Link]()

fp.set_preference("[Link]",2)
fp.set_preference("[Link]",Falso)
fp.set_preference("[Link]", [Link]())
fp.set_preference("[Link]","application/octet-stream
˓→ ")

navegador=[Link](perfil_firefox=fp)
[Link]("[Link]
browser.find_element_by_partial_link_text("selenium-2").click()

En el ejemplo anterior, application/octet-stream se utiliza como el tipo de contenido.

[Link] especifica el directorio donde deseas descargar los archivos.

¿Cómo subir archivos en entradas de archivos?

Selecciona el elemento <input type="file"> y llama al método send_keys() pasando la ruta del archivo, ya sea el
ruta relativa al script de prueba, o una ruta absoluta. Ten en cuenta las diferencias en los nombres de ruta entre Windows y
Sistemas Unix.

62 Capítulo 8. Apéndice: Preguntas Frecuentes

 Vínculos de Python de Selenium, Versión 2

¿Cómo usar Firebug con Firefox?

Primero descarga el archivo XPI de Firebug, luego llamas al método add_extension disponible para el perfil de firefox:

desde selenium importarwebdriver

fp=[Link]()

fp.add_extension(extension='[Link]')
fp.establecer_preferencia("[Link]","1.8.4")Evitar la pantalla de inicio
navegador=[Link](perfil_firefox=fp)

¿Cómo tomar una captura de pantalla de la ventana actual?

Utiliza el método savescreenshot proporcionado por el webdriver:

fromseleniumimportweb controlador

driver=[Link]()
[Link]('[Link]
driver.save_screenshot('captura_de_pantalla.png')
[Link]()

8.6. ¿Cómo usar Firebug con Firefox? 63

Vínculos de Selenium para Python, Lanzamiento 2

64 Capítulo 8. Apéndice: Preguntas Frecuentes

 CAPÍTULO 9

Índices y tablas

• índice de generación

• índice de módulos

buscar

65
Vínculos de Selenium para Python, Versión 2

66 Capítulo 9. Índices y tablas

 Índice de Módulos de Python

s
[Link].exceptions32
[Link],44
[Link].action_chains
35
[Link].alert38
[Link],41
[Link].capacidades_deseadas
41
[Link].keys39
[Link].utils42
[Link]
43
[Link],44
[Link]
52
[Link],58
[Link].expected_conditions
58
[Link],56
[Link].wait57

67
Vínculos de Selenium para Python, Versión 2

68 Índice de Módulos de Python

 Índice

A método)45
aceptar() ([Link] BACK_SPACE ([Link]
método)39 atributo)39
CadenasDeAcción (clase en sele- RETROCESO ([Link]
[Link].action_chains) atributo)39
35 Por (clase en [Link]),41
ADD (atributo [Link])
39
C
add_cookie() ([Link] ([Link] en-
método)44 tributo)39
Alerta (clase en [Link])38 CROMO ([Link].desired_capabilities.CapacidadesDeseadas
alerta_está_presente (clase en sele- atributo)42
[Link].expected_conditions) CLASS_NAME ([Link] en-
58 tributo41
todas las opciones seleccionadas (sele- BORRAR ([Link] en-
atributo [Link] tributo39
57 clear() ([Link]
ALT([Link] atributo) método)52
39 click() ([Link].action_chains.ActionChains
ANDROID ([Link]ún.capacidades_deseadas.CapacidadesDeseadas método)36
atributo)42 click() ([Link]
caché de aplicación (sele- método)52
[Link] clic_y_mantener() (sele-
atributo)51 [Link].action_chains.ActionChains
FLECHA_ABAJO (sele- método)36
atributo [Link] close() ([Link]
39 método)45
FLECHA_IZQUIERDA ([Link] Color (clase en [Link])58
atributo)39 MANDO ([Link]
Flecha derecha (sele- atributo)39
atributo de [Link] context() ([Link]
39 método)43
FLECHA_ARRIBA ([Link] CONTEXTO_CHROME (sele-
atributo),39 [Link]
authenticate() ([Link] atributo)44
método)39 context_click() ([Link].action_chains.ActionChains
método)36
B CONTENIDO_DEL_CONTEXTO (sele-
regresar() ([Link] [Link]
atributo)44

69
Vínculos de Selenium para Python, Versión 2

CONTROL ([Link] en- método)37

tributo39
E
crear_opciones() ([Link]
método)44 EDGE ([Link].desired_capabilities.DesiredCapabiliti
crear_elemento_web() (sele- atributo)42
[Link] elemento_localizado_estado_de_selección_a_ser (clase en sele-
método)45 [Link].expected_conditions)
CSS_SELECTOR ([Link] 58
atributo)41 elemento_ubicado_para_ser_seleccionado(clase en sele-
[Link] [Link].expected_conditions)
atributo)51 58
manejador_de_ventana_actual (sele- estado_de_selección_de_elemento_a_ser
(clase en sele-
[Link] [Link].expected_conditions)
atributo)51 58
elemento_a_ser_clickable (clase en sele-
D [Link].expected_conditions)
DECIMAL ([Link] en- 58
tributo)39 elemento_a_seleccionar (clase en sele-
ELIMINAR ([Link] [Link].expected_conditions),
atributo)39 58
eliminar_todas_las_galletas() (sele- ElementNotInteractableException,32
[Link] ElementNotSelectableException32
método)45 ElementNotVisibleException32
delete_cookie() ([Link]([Link] atributo),
método)4540
deseleccionar_todo() ([Link] INGRESAR ([Link] en-
método)56 tributo),40
deseleccionar_por_indice() (sele-IGUALA ([Link]
método [Link] atributo),40
56 ErrorEnRespuestaExcepción32
deseleccionar_por_valor() (sele- ESCAPE ([Link]
método [Link] atributo)40
56 ejecutar() ([Link]
deseleccionar_por_texto_visible() (método sele-)45
método [Link]), execute_async_script() (sele-
57 [Link]
capacidades_deseadas (sele- método),45
[Link] execute_script() ([Link]
atributo),51 método)45
CapacidadesDeseadas (clase en sele-
[Link].desired_capabilities) F
41 F1 (atributo [Link])40
descartar() ([Link] F10 (atributo [Link])
método)39 40
DIVIDIR ([Link] en- F11 (atributo [Link])
tributo)39 40
doble_click() ([Link].action_chains.ActionChains
F12 (atributo [Link])
método)36 40
ABAJO ([Link] en- F2 (atributo [Link])40
tributo)40 F3 (atributo [Link])40
arrastrar_y_soltar() ([Link].action_chains.ActionChains
F4 (atributo [Link])40
método)36 F5 (atributo [Link])40
arrastrar_y_soltar_por_desplazamiento() (sele- F6 (atributo [Link])40
[Link].action_chains.ActionChains F7 (atributo [Link])40

70 Índice
 Vínculos de Selenium para Python, Versión 2

F8 (atributo [Link])40 método)53

F9 (atributo [Link])40encontrar_elemento_por_xpath() (sele-
detector_de_archivos ([Link] [Link]
atributo)51 método),47
file_detector_context() (sele- encontrar_elemento_por_xpath() (sele-
[Link] [Link]
método)45 método)53
encontrar_ip_conectable() (en módulo sele-find_elements() ([Link]
[Link])42 método)47
find_element() ([Link]firnivde_relements() ([Link]
método)46método)53
find_element() ([Link]fiEnlde_meleenmtents_por_nombre_de_clase() (sele-
método),52 [Link]
encontrar_elemento_por_nombre_de_clase() (sele- método)47
[Link] encontrar_elementos_por_nombre_de_clase() (sele-
método)46 [Link]
encontrar_elemento_por_nombre_de_clase() (sele- método),53
[Link] encontrar_elementos_por_selector_css() (sele-
método)52 [Link]
encontrar_elemento_por_selector_css() (sele- método)47
[Link] encontrar_elementos_por_selector_css() (sele-
método)46 [Link]
encontrar_elemento_por_selector_css() (sele- método)53
[Link] encontrar_elementos_por_id() (sele-
método)52 [Link]
encontrar_elemento_por_id() (sele- método47
[Link] encontrar_elementos_por_id() (sele-
método)46 [Link]
encontrar_elemento_por_id() (sele- método)53
[Link] encontrar_elementos_por_texto_enlace() (sele-
método)52 [Link]
encontrar_elemento_por_texto_del_enlace() (sele- método),47
[Link] encontrar_elementos_por_texto_de_enlace() (sele-
método),46 [Link]
encontrar_elemento_por_texto_de_enlace() (sele- método)53
[Link] encontrar_elementos_por_nombre() (sele-
método)52 [Link]
encontrar_elemento_por_nombre() (sele- método)48
[Link] encontrar_elementos_por_nombre() (sele-
método)46 [Link]
encontrar_elemento_por_nombre() (sele- método)53
[Link] encontrar_elementos_por_texto_parcial_en_el_enlace() (sele-
método)53 [Link]
encontrar_elemento_por_texto_parcial_del_enlace()(sele- método),48
[Link] encontrar_elementos_por_texto_enlace_parcial() (sele-
método)47 [Link]
encontrar_elemento_por_texto_parcial_del_enlace()(sele- método)54
[Link] encontrar_elementos_por_nombre_de_etiqueta() (sele-
método)53 [Link]
encontrar_elemento_por_nombre_de_etiqueta() (sele- método)48
[Link] encontrar_elementos_por_nombre_de_etiqueta() (sele-
método)47 [Link]
encontrar_elemento_por_nombre_de_etiqueta() (sele- método),54
[Link] encontrar_elementos_por_xpath() (sele-

Índice 71
Bindings de Selenium para Python, Versión 2

[Link] H
método),48 AYUDA ([Link] en-
encontrar_elementos_por_xpath() (sele- tributo)40
[Link] hex ([Link] atributo)
método)54 58
FIREFOX ([Link].desired_capabilities.DesiredCapabilities
INICIO ([Link] en-
atributo)42 tributo),40
perfil_de_firefox ([Link]
HTMLUNIT ([Link].desired_capabilities.DesiredCap
atributo)44 atributo)42
primera_opción_seleccionada (sele- HTMLUNITCONJS (sele-
atributo de [Link] [Link].desired_capabilities.CapacidadesDeseadas
57 atributo)42
adelante() ([Link]
método)48 Yo
frame_a_disponible_y_cambiar_a_él (clase en sele-
ID (atributo [Link])41
[Link].expected_conditions)
id ([Link]
58
atributo)55
puerto_libre() (en módulo sele- ImeActivationFailedException33
[Link])43
ImeNotAvailableException33
from_string() ([Link]
implicitly_wait() ([Link]
método estático)58
método)49
G
get() ([Link]
método)48

método),54

método)48

método)48
get_log() ([Link]
método)48

método),54
get_screenshot_as_base64() (sele-
[Link]
método)48
get_screenshot_as_archivo() (sele-
[Link]
método),49
get_screenshot_as_png() (sele-
[Link]
método)49
obtener_posición_ventana() (sele-
[Link]
método)49
obtener_rectángulo_ventana() (sele-
[Link]
método)49
obtener_tamaño_ventana() (sele-
[Link]
método),49

72 Índice
 Bindings de Selenium para Python, Lanzamiento 2

K nombre ([Link]
key_down() ([Link].action_chains.ActionChains atributo)51
método),37 EVENTOS_NATIVOS_PERMITIDOS (sele-
key_up() ([Link].action_chains.ActionChains [Link]
método)37 atributo)44
Teclas (clase en [Link])39 se ha abierto una nueva ventana(clase en sele-
keys_to_typing() (en el módulo sele- [Link].expected_conditions)
[Link]),43 59
NoAlertPresentException34
L NoSuchAttributeException34
lanzar_aplicación() ([Link].WebDriverNoSuchElementException34
método),44 NoSuchFrameException34
IZQUIERDA (atributo [Link])NoSuchWindowException34
40 NULL ([Link] en-
LEFT_ALT([Link] en- tributo)40
tributo40 número_de_ventanas_a_ser (clase en sele-
CONTROL_IZQUIERDO (sele- [Link].expected_conditions)
atributo de [Link] 59
40 NUMPAD0 ([Link] en
LEFT_SHIFT ([Link] tributo)40
atributo)40 NUMPAD1 ([Link] en-
ENLACE_TEXTO ([Link] tributo)40
atributo)41 NUMPAD2 ([Link] en-
ubicación ([Link] tributo)40
atributo)55 NUMPAD3 ([Link] en-
ubicación_una_vez_desplazada_a_la_vista (sele- tributo)40
[Link] NUMPAD4 ([Link] en-
atributo)56 tributo)40
tipos_de_registro ([Link]) NUMPAD5 ([Link] en-
atributo)51 tributo40
NUMPAD6 ([Link] en-
M tributo)40
maximizar_ventana() (sele- NUMPAD7 ([Link] en-
[Link] tributo)40
método)49 NUMPAD8 ([Link] en-
META([Link] en- homenaje)40
tributo40 NUMPAD9 ([Link] en-
móvil ([Link] tributo41
atributo),51
mover_por_desplazamiento() (sele- O
ÓPERA ([Link].desired_capabilities.DesiredCapabili
[Link].action_chains.ActionChains
método)37 atributo)42
mover_a_elemento() selec- opciones ([Link] en-
[Link].action_chains.ActionChains tributo)57
método)37 orientación ([Link]
mover_a_elemento_con_desplazamiento() (sele- atributo)51
[Link].action_chains.ActionChains
método),37 P
MoveTargetOutOfBoundsException33 PAGE_DOWN ([Link]
MULTIPLICAR([Link] en- atributo)41
tributo)40 fuente_de_página ([Link]
atributo)51
N PAGE_UP ([Link] en-
NOMBRE (atributo [Link])41 tributo),41

Índice 73
Vínculos de Selenium para Python, Versión 2

padre ([Link].WebElemenstcreenshot_as_base64 (sele-

atributo)56 [Link]
TEXTO_DEL_ENLACE_PARTE (sele- atributo)56
[Link] atributo), captura_de_pantalla_como_png (sele-
41 [Link]
PAUSA ([Link] en- atributo),56
tributo41 Seleccionar (clase en [Link])56
realizar() ([Link].action_chains.ActiosneClehcat_inbsy_index() (sele-
método)38método [Link]
PHANTOMJS ([Link]ún.capacidades_deseadas.Desyo5r7capacidades de educación
atributo)42 seleccionar_por_valor() (sele-
presencia_de_todos_los_elementos_ubicados (clase en sele- método [Link]
[Link].expected_conditions) 57
59 seleccionar_por_texto_visible() (sele-
presencia_de_elemento_ubicado (clase en sele- método [Link]
[Link].expected_conditions) 57
59 [Link] (módulo)32
[Link] (módulo)44
Q [Link].action_chains (módulo)35
salir() ([Link] [Link] (módulo)38
método)44 [Link] (módulo)41
salir() ([Link] [Link].desired_capabilities (mod-
método),43 ule)41
salir() ([Link] [Link] (módulo)39
método),49 [Link] (módulo)42
[Link] (módulo)43
R [Link] (módulo)44
rect ([Link] [Link] (módulo)52
atributo)56 [Link] (módulo)58
refresh() ([Link] [Link].expected_conditions (mod-
método)49 ule)58
liberar() ([Link].action_chains.[Link] (módulo)56
método)38 [Link] (módulo)57
RemoteDriverServerException34 PUNTO Y COMA ([Link]
reset_actions() ([Link].action_chains.ActionChains atributo)41
método)38 send_keys() ([Link].action_chains.ActionChains
DEVOLVER ([Link] en- método),38
tributo)41 send_keys() ([Link]
rgb (atributo Color de [Link])58 método)39
rgba (atributo Color de [Link]) send_keys() ([Link]
58 método)55
DERECHA ([Link] en- enviar_claves_a_elemento() (sele-
tributo)41 [Link].action_chains.ActionChains
método),38
S SEPARADOR ([Link]
SAFARI ([Link].desired_capabilities.DesiredCapabilities)atributo)41
atributo)42 set_context() ([Link]
guardar_captura_pantalla() (sele- método)43
[Link] set_page_load_timeout() (sele-
método)49 [Link]
screenshot() ([Link] método),50
método)55 set_script_timeout() (sele-
[Link]
método),50

74 Índice
 Selenium Python Bindings, Lanzamiento 2

setear_posición_ventana() (sele- texto ([Link] atributo),

[Link] 39
método)50 [Link]
establecer_rectángulo_ventana() (sele- atributo)56
[Link] texto_a_estar_presente_en_el_elemento (clase en sele-
método)50 [Link].expected_conditions)
establecer_tamaño_ventana() (sele- 59
[Link] texto_a_presentar_en_el_valor_del_elemento (clase en sele-
método)50 [Link].expected_conditions
SHIFT ([Link] en- 59
tributo)41 TimeoutException35
tamaño ([Link] título ([Link]
atributo)56atributo),52
ESPACIO ([Link] en - título_contenido sele- (clase en
tributo)41 [Link].expected_conditions)
StaleElementReferenceException34 59
vencimiento de (clase en sele- title_is (clase en sele-
[Link].expected_conditions) [Link].expected_conditions)
59 59
iniciar_cliente() ([Link]
método)50 U
iniciar_sesión() ([Link]
UnableToSetCookieException35
método)50 UnexpectedAlertPresentException,35
stop_client() ([Link]ónUnexpectedTagName35
método)51 hasta() ([Link]
submit() ([Link] método)57
método)55 hasta_no() ([Link]
RESTAR ([Link] en- método)57
tributo)41 ARRIBA (atributo [Link])41
cambiar_a ([Link]
atributo)52 V
cambiar_a_elemento_activo() (sele- valor_de_propiedad_css() (sele-
[Link] [Link]
método),51 método)55
cambiar_a_alerta() (sele- visibilidad de (clase en sele-
[Link] [Link].expected_conditions)
método),51 59
cambiar_a_contenido_predeterminado() (sele- visibilidad_de_todos_los_elementos_ubicados (clase en sele-
[Link] [Link].expected_conditions)
método)51 60
cambiar_a_frame() (sele- visibilidad_de_cualquier_elemento_localizado (clase en sele-
[Link] [Link].expected_conditions)
método)51 60
cambiar_a_ventana() (sele- visibilidad_del_elemento_ubicado (clase en sele-
[Link] [Link].expected_conditions),
método)51 60
T W
TAB (atributo [Link]) Controlador Web (clase en sele-
41 [Link])44
NOMBRE_ETIQUETA ([Link] WebDriver (clase en sele-
atributo)41 [Link].webdriver43
nombre_etiqueta ([Link]
WebDriver (clase en sele-
atributo)56 [Link])44

Índice 75
Vínculos de Selenium para Python, Versión 2

WebDriverException,35
WebDriverWait (clase en sele-
[Link])57
WebElement (clase en sele-
[Link])cincuenta y dos
manejadores_de_ventana ([Link]
atributo)52

X
XPATH (atributo [Link])
41

76 Índice