Manejar dropdown y listas

Hice unas anotacioens al código de la clase

`import unittest
from selenium import webdriver
#submodulo  para usar el dropdown
from selenium.webdriver.support.ui import Select

class LanguageOptions(unittest.TestCase):
	def setUp(self):
		self.driver = webdriver.Chrome(executable_path = r'.\chromedriver.exe')
		driver = self.driver
		driver.implicitly_wait(30)
		driver.maximize_window()
		driver.get("http://demo-store.seleniumacademy.com/")
	
	def test_select_language(self):
		#el orden respeta como aparecen en la página
		exposed_options = ['English', 'French', 'German']
		#para almacenar las opciones que elijamos
		active_options = []
		#para acceder a las opciones del dropdown
		select_language = Select(self.driver.find_elements_by_id('select-language'))
		#para comprobar que si esté la cantidad de  opciones correcta
		#'options' permite ingresar directamente a las opciones del dropdown
		self.assertEqual(3, len(select_language.options))

		for option in select_language.options:
			active_options.append(option.text)
		
		#verifico que la lista de opciones disponibles y activas sean indénticas
		self.assertListEqual(exposed_options,active_options)

		#vamos a verificar la palabra "English" sea la primera opción seleccionada del dropdown
		self.assertEqual('English', select_language.first_selected_option.text)

		#seleccionamos "German" por el texto visible
		select_language.select_by_visible_text('German')

		#verificamos que el sitio cambio a Alemán
		#preguntamos a selenium si la url del sitio contiene esas palabras
		self.assertTrue('store=german' in self.driver.current_url)

		select_language = Select(self.driver.find_elements_by_id('select-language'))
		select_language.select_by_index(0)

	def tearDown(self):
		self.driver.implicitly_wait(3)
		self.driver.close()

if __name__ == "__main__":
	unittest.main(verbosity = 2)

Hace un tiempo tuve que automatizar testing a un sitio web que usaba react y unos dropdowns fueron todo un caos para seleccionar porque cambiaba su class y no tenían id y la estructura del DOM también se alteraba y no podía usar el xpath

IMPORTANTE: Selenium a partir de la versión (4.3.0) eliminó find_element_by_ y find_elements_by_ por lo cual ya no se puede usar.

Solución, cambiar por:
driver.find_element(By.XPATH, " ")
driver.find_elements(By.XPATH, " ")
driver.find_element(By.CLASS_NAME, " ")
driver.find_elements(By.CLASS_NAME, " ")

https://github.com/SeleniumHQ/selenium/blob/a4995e2c096239b42c373f26498a6c9bb4f2b3e7/py/CHANGES

Excelente

import unittest
from selenium import webdriver
from api_data_mock import ApiDataMock
from selenium.webdriver.support.ui import Select # Modulo para poder seleccionar del dropdown

class LanguageOptions(unittest.TestCase):

    def setUp(self):
        self.driver = webdriver.Chrome(executable_path = r'./chromedriver.exe')
        driver = self.driver
        driver.implicitly_wait(30)
        driver.maximize_window()
        driver.get('http://demo-store.seleniumacademy.com/')

    def test_select_language(self):
        exp_options = ['English', 'French', 'German' ]
        act_options = []

        select_language= Select(self.driver.find_element_by_id('select-language'))

        self.assertEqual(3, len(select_language.options))

        for option in select_language.options:
            act_options.append(option.text)

        #Verifico que las lsiatas sean iguales
        self.assertListEqual(act_options, exp_options)
        #Verifico que idionma esta seleciionado
        self.assertEqual('English', select_language.first_selected_option.text)
        #Seleccionar el idioma German
        select_language.select_by_visible_text('German')
        #verifico que en la url diga store=german
        self.assertTrue('store=german' in self.driver.current_url)
        #selecciono por indice me devuelvo a Ingles
        select_language= Select(self.driver.find_element_by_id('select-language'))
        select_language.select_by_index(0)

    def tearDown(self):
        self.driver.implicitly_wait(5)
        self.driver.close()


if __name__ == '__main__':
    unittest.main(verbosity=2)

Buen día,
Comparto mi código fuente

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from selenium.webdriver.support import select
from selenium.webdriver.support.ui import Select
class SearchTest(unittest.TestCase):
    
    def setUp(self):
        self.driver = webdriver.Chrome("D:\webdriver-chrome/chromedriver.exe")
        driver = self.driver
        driver.implicitly_wait(50)
        driver.maximize_window()
        driver.get('http://demo-store.seleniumacademy.com/')

    def test_select_language(self):
        exp_options = ['English','French', 'German']
        act_options = []

        select_language = Select(self.driver.find_element_by_id('select-language'))
        self.assertEqual(3, len(select_language.options))

        for option in select_language.options:
            act_options.append(option.text)

        self.assertEqual(exp_options, act_options)

        self.assertEqual('English',select_language.first_selected_option.text)

        select_language.select_by_visible_text('German')

        self.assertTrue('store=german' in self.driver.current_url)

        select_language = Select(self.driver.find_element_by_id('select-language'))
        select_language.select_by_index(0)



    def tearDown(self):
        self.driver.quit()


if __name__ == "__main__":
    unittest.main(verbosity=2,testRunner=HTMLTestRunner(output="reportes", report_name="prueba_asssert"))

Lo que hicismos en esta clase fue tomar las opciones de un dropdown:

select_language.py:

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.support.ui import Select #Así podremos elegir las opciones de un dropdown

class LanguageOptions(unittest.TestCase):

  @classmethod
  def setUpClass(cls):
    options = Options()
    options.add_argument('--headless')
    options.add_argument('--no-sandbox')
    options.add_argument('--disable-dev-shm-usage')
    cls.driver = webdriver.Chrome(executable_path = '/usr/bin/chromedriver' , options=options)
    driver = cls.driver
    driver.get('URL_DE_LA_WEB')


  def test_select_language(self):
    exposed_options = ['English', 'French', 'German'] # Los lenguajes disponibles de la página web, en ese orden
    active_options = []

    select_language = Select(self.driver.find_element_by_id('select-language'))

    self.assertEqual(3, len(select_language.options))

    for option in select_language.options:
      active_options.append(option.text) #Agregamos el texto a la lista

    self.assertListEqual(exposed_options, active_options) # Comparamos ambas listas, si son idénticas, la prueba pasará

    self.assertEqual('English', select_language.first_selected_option.text) #Verificamos que 'English' es la primera opción por defecto

    select_language.select_by_visible_text('German') #Verificamos que existe la opción con texto 'German'

    self.assertTrue('store=german' in self.driver.current_url) #Esta es parte de la URL con idioma en alemán

    select_language = Select(self.driver.find_element_by_id('select-language'))
    select_language.select_by_index(0) #Índex 0 es English, 1 es French y 2 es German


  @classmethod
  def tearDownClass(cls):
    cls.driver.quit()


if __name__ == '__main__':
  unittest.main(verbosity = 2)

Aquí si quieren una solución un poco más elegante podrían usar un comprehension list. Reemplacen la lista vacía y el bucle.

#active_options = []
#for option in select_language.options:
#active_options.append(option.text)

active_options = [option.text for option in select_language.options]

Como me gusta está clase!!! Aunque batalle un chorro al inicio para las instalaciones de dependencias. Valió totalmente la pena ❤️

La pagina web hoy no tiene la opción de seleccionar el lenguaje, no es posible hacer el ejercicio

Comparto la función con notas y corriendo para la versión 4.3.0 de selenium

def test_select_language(self):
        exp_option = ['English', 'French', 'German']
        act_options = []
        
        # Toma los elementos con Select y las añade a act_options
        select_language = Select(self.driver.find_element('id', 'select-language'))
        self.assertEqual(3, len(select_language.options))

        for option in select_language.options:
            act_options.append(option.text)
        
        # Verifica que las listas sean iguales
        self.assertListEqual(exp_option, act_options)
        
        # Validar que inglés sea el idioma seleccionado
        self.assertEqual('English', select_language.first_selected_option.text)

        # Selecciona alemán como idioma
        select_language.select_by_visible_text('German')

        # Verifica el cambio
        self.assertTrue('store=german' in self.driver.current_url)

        # Selecciona de nuevo el inglés
        select_language = Select(self.driver.find_element('id', 'select-language'))
        select_language.select_by_index(0)

Me encantó esta clase! Es increible como se puede automatizar toda la manipulación que se hace en una web.

Esta clase es totalmente practica aqui les dejo el codigo con comentarios:

import unittest
from selenium import webdriver
from selenium.webdriver.support.ui import Select#Modulo para manejar elementos dropdown

class LanguageOptions(unittest.TestCase):

    def setUp(self):
        self.driver = webdriver.Firefox(executable_path= r'./geckodriver.exe')
        driver = self.driver
        driver.implicitly_wait(3)
        driver.maximize_window()
        driver.get('https://demo-store.seleniumacademy.com/')

    def test_select_language(self):
        options = ['English', 'French', 'German'] #Listas con el nombre de las etiquetas
        act_options = []#Lista para almacenar las opciones al momento de revisar

        #Acceder a los elementos de la lista

        select_language = Select(self.driver.find_element_by_id('select-language'))

        #Validar si estan disponibles las opciones del dropdown

        self.assertEqual(3, len(select_language.options))#Esto nos permite ingresar a las opciones del dropdown

        for option in select_language.options:#Bucle para recorrer los elementos del dropdown
            act_options.append(option.text)#Agregar el texto

        #Comparacion de listas expuestas y activas

        self.assertListEqual(options, act_options)

        #Validar idioma por default

        self.assertEqual('English', select_language.first_selected_option.text) #Verificar que la palabra ingles esta por default

        #Seleccionar idioma del dropdown

        select_language.select_by_visible_text('German') #Seleccionar por el texto visible

        #Verificar que se cambio el idioma

        self.assertTrue('store=german' in self.driver.current_url)

        #Elegir un idioma mediante al indice

        select_language = Select(self.driver.find_element_by_id('select-language'))
        select_language.select_by_index(0)

    def tearDown(self):
        self.driver.implicitly_wait(3)
        self.driver.close()

if __name__ == "__main__":
    unittest.main(verbosity= 2)

Muy útil esta clase y lo que va del curso. Gracias

Los dropdown son los menús desplegables. Con selenium, podemos acceder a ellas mediante el texto que llevan, su orden o también por el valor que se tiene asignado en su código HTML.

para manejar nuestros dropdowns tenemos que importar el método Select: from selenium.webdriver.support.ui import Select

Dentro de los métodos de nuestro Select, tenemos las diferentes posibilidades , como select_by_index(), select_by_value(), select_by_visible_text(), que por sus nombres, nos empiezan a acordar lo que el profe dijo al principio.

No tengo idea por qué, pero la parte:

select_language = Select(self.driver.find_element_by_id('select-language'))

La modifiqué por:

xpath_dropDown = '//*[@id="select-language"]'
select_language = Select(self.driver.find_element_by_xpath(xpath_dropDown)) 

y todo ok.

Dejó el comentario por si alguien ha tenido problemas con eso, en todo caso, si un compañero sabe del por qué la situación sería genial que lo explicara.

Una alternativa que se me ocurre es que cambiaron la API estos compadres.

Les comparto mi código; yo usé este otro sitio para hacer las pruebas. Con mi código registro 10 nuevos usuarios y reviso que se hayan creado correctamente. La información de los nuevos usuarios la obtengo de mockaroo que sirve para hacer bases de datos de prueba que me va a ser muy útil para próximos proyectos.

Yo uso Brave por eso mi setUp es un poco diferente

import unittest
import requests
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.support.select import Select

class RegisterNewUser(unittest.TestCase):

    @classmethod
    def setUp(cls):
        options = Options()
        options.binary_location = '/snap/brave/119/opt/brave.com/brave/brave'
        cls.driver = webdriver.Chrome(options = options, executable_path="./chromedriver")
        driver = cls.driver
        driver.get("h tt p : //a uto ma t ion p ract ice . c o m /index.php")
        driver.maximize_window()
    
    def test_reg_many_users(self):
        driver = self.driver

        driver.find_element_by_link_text("Sign in").click()
        driver.implicitly_wait(5)

        for fake_user in self.get_fake_users():

            account_error = driver.find_element_by_id("create_account_error")
            self.assertFalse(account_error.is_displayed())

            #Starts creation
            email_field = driver.find_element_by_xpath('//*[@id="email_create"]')
            email_field.clear()
            email_field.send_keys(fake_user["email"])

            driver.find_element_by_xpath('//*[@id="SubmitCreate"]').click()

            #Fills up the full form

            ##### Radio buttons #####
            driver.implicitly_wait(5)
            if fake_user['gender'] == "female":
                driver.find_element_by_xpath('//*[@id="id_gender2"]').click()
            else:
                driver.find_element_by_xpath('//*[@id="id_gender1"]').click()

            #### Text inputs ########
            f= driver.find_element_by_id("customer_firstname")
            f.clear()
            f.send_keys(fake_user['first_name'])

            f= driver.find_element_by_id("customer_lastname")
            f.clear()
            f.send_keys(fake_user['last_name'])

            f= driver.find_element_by_id("email")
            f.clear()
            f.send_keys(fake_user['email'])

            f= driver.find_element_by_id("passwd")
            f.clear()
            f.send_keys(fake_user['password'])

            ##### Selects ######
            birthday = fake_user['birthday'].split(".")
            Select(driver.find_element_by_id("days")).select_by_value(birthday[0])
            Select(driver.find_element_by_id("months")).select_by_value(birthday[1])
            Select(driver.find_element_by_id("years")).select_by_value(birthday[2])

            #### Checkbox #####
            if fake_user['newsletter']:
                driver.find_element_by_xpath('//*[@id="newsletter"]').click()

            if fake_user['offers']:
                driver.find_element_by_xpath('//*[@id="optin"]').click()
            
            f= driver.find_element_by_id("firstname")
            f.clear()
            f.send_keys(fake_user['first_name_address'])

            f= driver.find_element_by_id("lastname")
            f.clear()
            f.send_keys(fake_user['last_name_address'])

            f= driver.find_element_by_id("company")
            f.clear()
            if fake_user["company"]:
                f.send_keys(fake_user['company'])

            ### Select dropdown ###
            Select(driver.find_element_by_id("id_state")).select_by_value(str(fake_user['state']))

            f= driver.find_element_by_id("city")
            f.clear()
            f.send_keys(fake_user['city'])

            f= driver.find_element_by_id("address1")
            f.clear()
            f.send_keys(fake_user['address'])

            f= driver.find_element_by_id("postcode")
            f.clear()
            f.send_keys(fake_user['postal_code'])

            f= driver.find_element_by_id("phone")
            f.clear()
            if fake_user['home_phone']:
                f.send_keys(fake_user['home_phone'])

            f= driver.find_element_by_id("phone_mobile")
            f.clear()
            f.send_keys(fake_user['phone'])

            f= driver.find_element_by_id("alias")
            f.clear()
            f.send_keys(fake_user['alias'])

            driver.find_element_by_id("submitAccount").click()

            #Checks the user has been created with the same full name
            full_name = fake_user["first_name"] + " " + fake_user["last_name"]
            driver.implicitly_wait(5)
            self.assertEqual(driver.find_element_by_xpath('//*[@id="header"]/div[2]/div/div/nav/div[1]/a/span').text, full_name)

            #Signs out to create a new user
            driver.find_element_by_link_text("Sign out").click()

    def get_fake_users(self, n_users=10):
        fake_users = requests.get("https://api.mockaroo.com/api/cc2af970?count=" + str(n_users) + "&key=e1dda320")
        return fake_users.json()

    @classmethod
    def tearDown(cls):
        cls.driver.quit()

if __name__ == "__main__":
    unittest.main(verbosity=2, testRunner=HTMLTestRunner(output="reportes", report_name="automatic_search"))

Versión actualizada para el 2024, totalmente funcional

import unittest
from pyunitreport import HTMLTestRunner # para generar el reporte en html
from selenium import webdriver
from selenium.webdriver.chrome.service import Service # Service es una clase que se encarga de abrir el navegador
from webdriver_manager.chrome import ChromeDriverManager # para que se abra el navegador
from selenium.webdriver.common.by import By # Clase moderna para buscar elementos
from selenium.webdriver.support.ui import Select # Clase para manejar listas desplegables

class LanguageOptions(unittest.TestCase):

    # Se ejecuta al inicio de cada test, abrir el navegador
    def setUp(self):
        self.driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
        driver = self.driver
        driver.implicitly_wait(15)
        driver.maximize_window()
        driver.get(" http :// demo-store . seleniumacademy . com /") # <<--eliminar los espacios en la URL

    def test_select_language(self):
        exp_options = ["English", "French", "German"] # creamos una lista con las opciones esperadas
        act_options = [] # creamos una lista vacía para las opciones actuales
        # Asegúrate de que 'select_language' es un elemento 'select'
        # select_language = self.driver.find_element(By.ID, "select-language") # versión antigua
        select_language = Select(self.driver.find_element(By.ID, "select-language")) # Busca la lista desplegable de idiomas por su id

        # Ahora puedes acceder a 'options'
        options = select_language.options
        # self.assertEqual(3, len(select_language.find_elements(By.TAG_NAME, "option"))) # versión antigua
        self.assertEqual(3, len(options)) # Comprueba que haya 3 opciones en la lista desplegable

        # for option in select_language.find_elements(By.TAG_NAME, "option"): # versión antigua
        for option in select_language.options: # Recorre cada opción de la lista desplegable
            act_options.append(option.text) # Agrega el texto de la opción a la lista de opciones actuales, solo el texto, no el valor html

        self.assertEqual(exp_options, act_options) # Comprueba que las opciones de ambas listas esperadas sean iguales a las opciones actuales

        first_option = select_language.first_selected_option # Obtiene la opción seleccionada por defecto
        # self.assertEqual("English", select_language.first_selected_option.text)  # versión antigua
        self.assertEqual("English", first_option.text) # Comprueba que la opción seleccionada por defecto sea "English"

        select_language.select_by_visible_text("German") # Selecciona la opción "German" de la lista desplegable

        self.assertTrue("store=german" in self.driver.current_url) # Comprueba que la URL actual contenga "store=german"

        select_language = Select(self.driver.find_element(By.ID, "select-language")) 
        select_language.select_by_index(0) # Selecciona la primera opción de la lista desplegable

    # Se ejecuta al finalizar cada test, cerrar el navegador
    def tearDown(self):
        self.driver.quit()


if __name__ == "__main__":
    unittest.main(
        testRunner=HTMLTestRunner(output="reportes", report_name="hello-world-report"),
        verbosity=2,
    )

Les comparto mi codigo con un poco de documentación:

import unittest
from selenium import webdriver
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.by import By


class LanguageOptionsTests(unittest.TestCase):

    def setUp(self) -> None:
        self.driver = webdriver.Chrome(executable_path='./chromedriver')
        driver = self.driver
        driver.get("https://demo-store.seleniumacademy.com/")
        driver.maximize_window()
        driver.implicitly_wait(15)

    def test_select_language(self):
        exp_options = ['English', 'French', 'German']
        act_options = []

        select_language = Select(self.driver.find_element(By.ID, 'select-language'))

        self.assertEqual(3, len(select_language.options))

        for option in select_language.options:
            act_options.append(option.text)

        self.assertListEqual(exp_options, act_options)

        self.assertEqual('English', select_language.first_selected_option.text)

        select_language.select_by_visible_text('German')

        self.assertTrue('german' in self.driver.current_url)

        # The instance is obtained again to avoid errors and not lose de context
        select_language = Select(self.driver.find_element(By.ID, 'select-language'))

        # The English language is selected again
        select_language.select_by_index(0)

    def tearDown(self) -> None:
        self.driver.quit()


if __name__ == "__main__":
    unittest.main(verbosity=2)

import unittest
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
from pyunitreport import HTMLTestRunner
from selenium.webdriver.support.ui import Select
class LanguageOptions(unittest.TestCase):
    @classmethod
    def setUp(self):
        self.driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
        driver = self.driver
        driver.implicitly_wait(30)
        driver.maximize_window()
        driver.get(" url web")
	
    def test_select_language(self):
        exp_option = ['English', 'French', 'German']
        act_options = []
        
        # Toma los elementos con Select y las añade a act_options
        select_language = Select(self.driver.find_element('id', 'select-language'))
        self.assertEqual(3, len(select_language.options))

        for option in select_language.options:
            act_options.append(option.text)
        
        # Verifica que las listas sean iguales
        self.assertListEqual(exp_option, act_options)
        
        # Validar que inglés sea el idioma seleccionado
        self.assertEqual('English', select_language.first_selected_option.text)

        # Selecciona alemán como idioma
        select_language.select_by_visible_text('German')

        # Verifica el cambio
        self.assertTrue('store=german' in self.driver.current_url)

        # Selecciona de nuevo el inglés
        select_language = Select(self.driver.find_element('id', 'select-language'))
        select_language.select_by_index(0)
    def tearDown(self):
        self.driver.implicitly_wait(3)
        self.driver.close()

if __name__ == "__main__":
     unittest.main(verbosity = 2, testRunner = HTMLTestRunner(output = 'reports', report_name = 'reoporte_select_language'))
	

ok

Este es mi código, agrege el cambio de idioma a Frances.

import unittest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.service import Service
# import submodule of selenium to manipulade dropdown
from selenium.webdriver.support.ui import Select

class LanguageOptions(unittest.TestCase):

    def setUp(self):
        self.driver = webdriver.Chrome(service=Service('./chromedriver'))
        driver = self.driver
        driver.implicitly_wait(30)
        driver.maximize_window()
        driver.get('http://demo-store.seleniumacademy.com/')

    def test_select_language(self):
        exp_options = ['English', 'French', 'German']
        act_options = [] 

        select_language = Select(self.driver.find_element(By.ID, 'select-language')) 
        
        self.assertEqual(3, len(select_language.options))
        
        for option in select_language.options:
            act_options.append(option.text)

        self.assertListEqual(exp_options, act_options)
        self.assertEqual('English', select_language.first_selected_option.text)

        # Change language to French and valided change
        select_language.select_by_visible_text('French')
        self.assertTrue('store=french' in self.driver.current_url)
        
        select_language = Select(self.driver.find_element(By.ID, 'select-language'))
        # Change language to German and valided change
        select_language.select_by_visible_text('German')
        self.assertTrue('store=german' in self.driver.current_url)


        # Change to English
        select_language = Select(self.driver.find_element(By.ID, 'select-language'))
        select_language.select_by_index(0)

    def taerDown(self):
        self.driver.implicitly_wait(30)
        self.driver.close()
        
if __name__ == '__main__':
    unittest.main(verbosity = 2)```

codigo

import unittest
from selenium import webdriver
from pyunitreport import HTMLTestRunner
from selenium.webdriver.support import select
from selenium.webdriver.support.ui import Select


class RegiserNewUser(unittest.TestCase):

    def setUp(self):
        self.driver = webdriver.Chrome(executable_path='./chromedriver')
        driver = self.driver
        driver.implicitly_wait(30)
        driver.maximize_window()
        driver.get('http://demo-store.seleniumacademy.com/')
 
    def select_lenguage(self):
        exp_options = ['English', 'French', 'German' ]
        act_options = []

        select_language = Select(self.driver.find_element_by_id('select-lenguage'))

        self.assertEqual(3, len(select_language.options))

        for option in select_language.options:
            act_options.append(option.text)

        self.assertListEqual(exp_options, act_options)

        self.assertEqual('English', select_language.first_selected_option.text())

        select_language.select_by_visible_text('German')

        self.assertTrue('store=german' in self.driver.current_url)

        select_language = Select(self.driver.find_element_by_id('select_language'))

        select_language.select_by_index(0)
        

    def tearDown(self):
        self.driver.implicitly_wait(30).quit()


if __name__ == '__main__':
    unittest.main(verbosity=2, testRunner= HTMLTestRunner(output= 'reports', report_name= 'hello-world-report'))

Que clase mas satisfactoria para terminar el día. 🤠

Hola les comparto mis anotaciones 😄

Selenium Notion

Con la novedad de que el dropdown de lenguaje ya no existe o al menos no en Chrome, pero…

encontre un dropdown en el mismo sitio pero en la pagina de ordenes -> https://demo.onestepcheckout.com/sales/guest/form/

solo hay que modificar el código un poco…

¿Por qué cuando vuelvo a seleccionar el idioma ingles debo volver a inicializar la variable select_language? son las últimas 2 líneas de código de la función test_select_language()

select_language = Select(self.driver.find_elements_by_id('select-language'))
select_language.select_by_index(0)```

Hola a todos,

Alguien sabe como se pueden capturar elementos de una lista que está etiquetada de esta forma:

<<div class="format-markdown"><p>👩 Buenos dias Aquí podrás:</p>
<br><ol>
<li>opción 1</li>
<li>opción 2</li>
<li>opción 3</li>
<li>opción 4</li>
<li>opción 5</li>
<li>opción 6</li>
<li>opción 7</li>
</ol>
<br><p>¿En qué te puedo ayudar?</p>
</div>>

que bien