¡Hola, mundo!

Para el caso de que tu S.O. sea Ubuntu y tengas instalado el navegador Google Chrome debes correr previamente en la terminal:

• sudo apt-get install chromium-chromedriver

y tu setUpClass debe ser así:

@classmethod 
    def setUpClass(cls):
        cls.driver = webdriver.Chrome(executable_path='/usr/bin/chromedriver')
        driver = cls.driver
        driver.implicitly_wait(10)

Buen dia les comparto mi codigo por si a alguien le sirve.

# Con unittest nos podemos traer todas nuestras pruebas
import unittest
# Ayuda a orquestar cada una de las pruebas que estaremos
# ejecutando junto con los reportes
from pyunitreport import HTMLTestRunner
# Para comunicarnos con el navegador usamos webdriver
from selenium import webdriver

class HelloWorld(unittest.TestCase):
	# Realiza todo lo necesario antes de empezar la prueba
    @classmethod # Decorador para que las distintas paginas corran en una sola pestaña
    def setUpClass(cls):
        cls.driver = webdriver.Chrome(executable_path=r"./chromedriver.exe")
        driver = cls.driver
		# esperamos 10 seg antes de realizar la siguiente accion
        driver.implicitly_wait(10)

	# Caso de prueba donde realizaremos una serie de acciones para que el navegador las automatice
    def test_hello_world(self):
        driver = self.driver
        driver.get('https://www.platzi.com')

    def visit_wikipedia(self):
        self.driver.get('https://www.wikipedia.com')
        
		
	# Cerramos el navegador una vez terminadas las pruebas
    @classmethod
    def tearDownClass(cls):
        cls.driver.quit()

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

Lo bueno de tener una pc lenta es que en estos casos se nota la diferencia. Casi un 50% 😄

Llevo literalmente una semana intentando hacer esta prueba.
Uso WSL2, pero me daba error siempre que intentaba realizar la prueba (y simplemente no me abría la página de Chrome).

Intenté usar Anaconda para instalar las librerías que necesitaba, ejecutar el programa desde la PowerShell, instalar todo tipo de entornos virtuales. Incluso intenté instalar una interfaz gráfica para la terminal de WSL en Windows (un proceso bastante laborioso y además muy inseguro, puesto que requiere otorgar permisos a este programa que no me gustaron).

Al final mi solución fue instalar Ubuntu en una computadora que no es mi principal. Me funcionó perfecto en un sistema LInux.

¡Además, será mi oportunidad para familizarme con este sistema operativo!

El profesor menciona que se debe colocar la liga completa, en mi caso uso windows 10, uso python 3.8 y no fue necesario.

self.driver = webdriver.Chrome(executable_path = r'./chromedriver.exe')

Si te aparece el siguiente error: DeprecationWarning: executable_path has been deprecated, please pass in a Service object self.driver = webdriver.Chrome(executable_path=r"./chromedriver.exe")

Te comparto la solución que a mi me sirvio (Estoy usando windows 11 y la feca es 20/02/2022)

• Instalar la siguiente librería

pip3 install webdriver_manager

• Importar en el código

from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager

• Cambiar la linea self.driver donde llamas el chromedriver por

self.driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))

y listo, todo el demás código que se muestra en el vídeo queda igual.

Hola paso también la solución al error que tenia al no poder abrir el navegador y correr los tests del scripts del hola mundo:

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver


class HelloWorld(unittest.TestCase):

    def setUp(self):
        self.driver = webdriver.Chrome(executable_path='./chromedriver')
        driver = self.driver
        driver.implicitly_wait(10)

    def test_hello_world(self):
        driver = self.driver
        driver.get('http://demo-store.seleniumacademy.com/')

    def test_visit_wikipedia(self):
        self.driver.get('https://www.wikipedia.org')

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

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

el error era de indentación en la última línea de código, recien lo pude ver gracias al apoyo del profesor Héctor. Lo paso por si alguien tiene el mismo problema y no ve cual puede ser el error, saludos y gracias Héctor.

Si están en Windows y les sale un error, el problema está en el ejecutable y en que el término executable_path ya está deprecado.

Para solucionarlo primero onstalé lo siguiente:

pip3 install webdriver-manager

Y luego mi código quedó así:

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager

class HelloWorld(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.driver = webdriver.Chrome(service = Service(ChromeDriverManager().install()))
        cls.driver.implicitly_wait(10)
    
    def test_hello_world(self):
        self.driver.get('https://www.netflix.com')

    def test_visit_wikipedia(self):
        self.driver.get('https://www.wikipedia.org')

    @classmethod
    def tearDownClass(cls) -> None:
        cls.driver.quit()

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

Con esto no hay necesidad de descargar el chromedriver en sus computadoras y tampoco necesitan usar WSL porque todo corre en Powershell. Espero les sirva.

Les comparto mi código ya con comentarios.
Entorno : windows 10 + python 3.8

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver

class HelloWorld(unittest.TestCase):

	#va a ejecutar todo lo necesario antes de hacer una prueba
	#va a preparar el entorno de la prueba
	@classmethod  # para que abra las pestañas en una misma ventana
	def setUpClass(cls):
		cls.driver = webdriver.Chrome(executable_path = r'.\chromedriver.exe')
		driver = cls.driver
		driver.implicitly_wait(10)
	
	#aquí va lo que queremos que la prueba haga
	def test_hello_world(self):
		driver = self.driver
		driver.get('https://platzi.com/')

	def test_visit_wikipedia(self):
		self.driver.get('https://es.wikipedia.org/')

	#cierra el navegador para evitar 
	#fuga de recursos
	@classmethod #decorador para que no se cierre la ventana después de la primera prueba
	def tearDownClass(cls):
		cls.driver.quit()



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

Hola! Estoy siguiendo el curso con Ubuntu corriendo en WSL2, estuve un rato navegando y me encontre con que la unica forma de correr el driver de Chrome con esta configuración es llamandolo desde la ruta contenedora en Windows, al intentar ejecutar el codigo me sale el siguiente error

No he podido solucionarlo y en la red no hay mucha información, un comentario de hace 4 meses dice que no es posible correr Selenium en WSL2 pero por el mensaje de error creo que solo se debe a que no logra ejecutar el driver. ¿Tiene alguna solución?

dejare la palabra frustrante, porque es eso lo que merece, 20 error me saltan en cada clase y el instructor dicta un montón de cosas sin dar una buena explicación. no deben olvidar que la persona que ingresa al curso no sabe y quiere aprender para que sirve cada cosa. abandono el curso.

Hola amigos,
.
A mi me causó mucha curiosidad el porque al agregar el decorador @classmethod nuestras pruebas (en este caso visitas al sitio web de Platzi y Wikipedia) se hicieron en la misma ventana. Investigando encontré lo siguiente:
.
Los métodos setUp y tearDown se ejecutan cada vez que se lanza una prueba (métodos que empiezan con el prefijo test_). Por ello nuestra ventana se abre para visitar un sitio, se cierra y se vuelve a abrir para visitar el otro.
.
Para evitar esto, se agrega el decorador @classmethod, este decorador permite recibir la clase como primer parámetro dentro de un método y ejecutar directamente dicho método sin depender de la instancia de la clase que lo contiene. Wow, wow, wow! Espera, yo también me confundí cuando leí esto por primera vez. Pero puedes encontrar una explicación más clara justo AQUI.
.
Pero la magia no ocurre solo con el decorador @classmethod, si intentas ejecutar las pruebas aún con el decorador (y la debida modificación de los métodos setUp y tearDown) verás que las pruebas aún ocurren en ventanas separadas 😱😱 Esto se debe a que parte de la magia va de la mano con los métodos setUpClass y tearDownClass. La razón es porque 2 últimos métodos se ejecutan para toda la clase y no solo para cada método de pruebas. WOOOOOW!
.
Si lo vemos con un flujo encontramos lo siguiente:

Espero les haya servido la explicación, ¡saludos y nunca paren de aprender! 💚💚💚

Hola, me sale este error

ModuleNotFoundError: No module named 'pyunitreport'

Si quieren una forma mas sencilla de descargar el driver, pueden descargarse con pip la libreria “webdriver_manager”.

from webdriver_manager.chrome import ChromeDriverManager

driver = webdriver.Chrome(ChromeDriverManager().install())

Haré un tutorial de como ver el curso desde windows sub-system for linux.

Espero pronto les guste 😄

Por si a alguien le aparece un error al importar selenium o pyunitreport en visual studio code, esto es un error visual del editor, no genera ningún error al tratar de ejecutar el script, aunque si lo desea puede usar otro IDE como PyCham.

Cosas importantes de Unittest (PyTest)

• Test Fixture: preparaciones para antes y después de la prueba
• Test Case: unidad de código a probar
• Test Suite: colección de Test Cases
• Test Runner: orquestador de la ejecución
• Test Report: resumen de resultados

1. Instalar: sudo apt-get install python3.8-venv
2. Ejecutar: sudo python3.8 -m venv nombreDelProyecto
3. Crear alias: alias avenv="source venv/bin/activate" (venv es el nombre del proyecto)
4. Ejecutar alias: avenv

Para instalar Chrome en Ubuntu 20.04

wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb

sudo apt install ./google-chrome-stable_current_amd64.deb

IMPORTANTE: Para poder instalar con pip las librerías solamente en el entorno virutal de Python, hay que modificar el archivo “pyvenv.cfg”

home = /usr/bin
include-system-site-packages = true #!debe estar en true
version = 3.8.5

Si no deja modificar, ejecutar: sudo chown -r nombre_de_usuario directorio_del_proyecto, en mi caso fue: sudo chown -r mike_angel_rm /home/mike_angel_rm/personalProjects/CursoIntroduccionSeleniumPython

Apagamos el entorno virtual y lo volvemos a encender. Instalamos las librerías.

Si el código no funciona, esto funcionó para mí en WSL2:

hello_world.py:

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from selenium.webdriver.chrome.options import Options

class HelloWorld(unittest.TestCase):

  @classmethod
  def setUpClass(cls): # Qué es lo que se va a hacer
    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) #Ruta de driver en unix
    driver = cls.driver # Para no tener que escribir self driver en cada línea
    #driver.implicity_wait(10)


  def test_hello_world(self):
    driver = self.driver
    driver.get('https://www.platzi.com')


  def test_visit_wikipedia(self):
    driver = self.driver
    driver.get('https://www.wikipedia.org')


  @classmethod
  def tearDownClass(cls):
    cls.driver.quit() # Cerramos la ventana del navegador después de cada prueba


if __name__ == '__main__':
  # output es el nombre del reporte
  unittest.main(verbosity=2 , testRunner= HTMLTestRunner(output = 'reportes', report_name='hello-world-report'))

Es importante tener chrome/chromium y chromedriver instalados en WSL2.

Previamente trabaje con Selenium y tuve bastantes problemas con WebDriver, por lo cual encontré la dependencia webdriver-manager. Es muy útil ya que sin importar la versión de chrome esta instalara el WebDriver adecuado:

Instalacion:

pip install webdriver-manager

Uso en Python:

from selenium import webdriver
from webdriver_manager.chrome import ChromeDriverManager

driver = webdriver.Chrome(ChromeDriverManager().install())

Espero les sea útil. Con esto no hay necesidad de descargar el web driver cada vez que cambiemos de versión de Chrome.

si les sale un error en mac diciendo que es software malicioso vayan a la carpeta donde esta el web driver presionen click derecho y abrir, se abrira una nueva terminal y sin cerrar esa terminal ya pueden ejecutar el programa en python

Hola, les quería compartir que estuve un largo rato buscando el error y termino siendo la ruta del chormedriver. La forma que me funcione en Ubunto for Windows fue con :

self.driver = webdriver.Chrome(executable_path = r'./chromedriver.exe')```

Hola, para los que usamos Microsoft Edge la línea de setUpClass quedaría así:

	@classmethod
	def setUp(cls):
		cls.driver = webdriver.Edge(executable_path = r'./Driver/msedgedriver')
		driver = cls.driver
		driver.implicitly_wait(10)

Por favor alguien que me colabore, cuando corro este codigo, todo funciona pero sale un mensaje diciendo que no se ha especificado el template del HTML reports, aunque genera los reportes pero en otra carpeta por fuera de la carpeta donde estoy trabajando.

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver

class HelloWorld(unittest.TestCase):

    
    def setUp(self):
        self.driver = webdriver.Chrome(executable_path = r"G:\\PLATZI\\PROYECTOS_PLATZI\\Curso de Introducción a Selenium\\chromedriver.exe")
        driver = self.driver
        driver.implicitly_wait(10)

    def test_hello_world(self):
        driver = self.driver
        driver.get('https://www.platzi.com')

    def test_visit_wikipedia(self):
        driver = self.driver
        driver.get('https://www.wikipedia.org')

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

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

2023

¿cómo hice para no trabarme en esta clase en windows?

1. Creé una carpeta donde puse el webdriver de chrome y en ese misma carpeta puse mis archivos de python
2. Creé un entorno virtual donde instalé todos los paquetes que usamos

Y listo :3

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver

class HelloWorld(unittest.TestCase):
    def setUp(self) -> None:
        #Ejecuta todo lo necesario antes de hacer una prueba, prepara el entorno de la prueba misma
        self.driver = webdriver.Chrome(r'../chromedriver.exe')
        driver = self.driver
        driver.implicitly_wait(10)


    def test_hello_world(self):
        #caso de prueba donde se realizarán una serie de acciones para que el navegador las automatice
        driver = self.driver
        driver.get("https://www.google.com")
        

    def tearDown(self) -> None:
        #acciones para finalizar
        self.driver.close()



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

Mi problema con executable_path era que no estaba indicando la ruta donde se encuentra chromedriver.
Si tu ejecutas el script desde una capeta Z y chromedriver esta en una carpeta Y, tienes que indicar la ruta para llegar a la carpeta Y. (entorno= Ubuntu 20.04 en WSL2)

Para las personas que realicen este curso despues de mayo del 2022 deben hacer unos cambios y es que el driver se debe ejecutar como servicio y eso se hace de la siguente manera:

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.support.ui import WebDriverWait


class HolaMundo(unittest.TestCase):

    def setUp(self) -> None:
        chrome = Service(r"C:\Drivers\chrome\chromedriver.exe")
        self.driver = webdriver.Chrome(service=chrome)
        WebDriverWait(self.driver, 10)

    def test_hola(self):
        self.driver.get("https://www.google.com/")

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


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

A mi me daba un error de pyunitreport could not be resolved pero lo arregle usando el comando:

$ pip install PyUnitReport

Para los que usan firefox como yo, les dejo el repo de geckodriver que es el que toca usar en firefox.
El código queda prácticamente igual:

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver

class HellowWorld(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.driver = webdriver.Firefox(executable_path = r'./geckodriver')
        driver = cls.driver
        driver.implicitly_wait(10)
    
    def test_hello_world(self):
        driver = self.driver
        driver.get('https://platzi.com')

    def test_visit_wikipedia(self):
        self.driver.get('https://wikipedia.org')
    
    @classmethod
    def tearDownClass(cls):
        cls.driver.quit()

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

Hola! yo tuve el mismo inconveniente de muchos en esta sesión…la ejecución del script no era satisfactoria, pero por fin lo pude solucionar instalando una librería llamada wheel, acá les dejo el link https://pypi.org/project/wheel/. También ajuste un poco el código con la ayuda de algunos comentarios de los compañeros y lo tabule bien pues no había identado bien las dos líneas del final. Lo probé en Linux y en Windows y funcionó!!! 😃, les dejo la imagen del código y la ejecución. Espero les les sirva mi comentario!

Alguien mas esta usando EDGE?

Para los que quieren usar Brave como navegador, pueden “ChromeOptions()” del webdriver. Les dejo mi código:

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver

driver_path = "/mnt/c/Users/XXXX/Documents/Personal/selenium-course/chromedriver.exe" #Uso la notación de ruta de UNIX porque uso la terminal de Linux en Win10
brave_path = "C:/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"

option = webdriver.ChromeOptions()
option.binary_location = brave_path

class HelloWorld(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.driver = webdriver.Chrome(executable_path=driver_path, chrome_options=option)
        cls.driver.implicitly_wait(10)

    def test_hello_world(self):
        self.driver.get("https://www.google.com")

    def test_visit_wikipedia(self):
        self.driver.get("https://www.wikipedia.org")

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

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

Logré crear de manera exitosa el ¡Hola, mundo!, gracias Héctor!

Actualización para el 2024, con windows

1. no es necesario descargar ChromeDriver
2. El siguiente código corre

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager


class HelloWorld(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
        driver = cls.driver
        driver.implicitly_wait(20)

    # aquí al medio van los tests
    def test_hello_world(self):
        driver = self.driver
        driver.get("https://www.platzi.com")

    def test_visit_wikipedia(self):
        driver = self.driver
        driver.get("https://www.wikipedia.org")

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


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

Se que puede ser frustrante ver errores y no saber que hacer, pero si algo he aprendido programando es que los errores son nuestros amigos, porque así es la vida profesional muchas veces vas a llegar a un punto donde no sabes que hacer, donde no hay tutoriales ni cursos ni tiempo, solo nos queda sentarnos con cabeza fría y entender qué nos dice el computador.

Ya volviendo al tema, hice la prueba con Ubuntu 22.04 y Chrome con el código del curso y corrió sin problemas, solo con la advertencia del código desactualizado, sin embargo vi algunos comentarios y corrió quitando las advertencias. He visto que algunos tienen problemas con la terminal así que pueden hacer el curso que hay en platzi.

from selenium.webdriver.chrome.service import Service
from pyunitreport import HTMLTestRunner
from selenium import webdriver
import unittest


class Hello(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.driver = webdriver.Chrome(
            service=Service(r"./driver/chromedriver"))
        driver = cls.driver
        driver.implicitly_wait(10)

    def testHello(self):
        driver = self.driver
        driver.get("https://www.platzi.com")

    def testWiki(self):
        driver = self.driver
        driver.get("https://www.wikipedia.org")

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


if __name__ == "__main__":

    unittest.main(verbosity=2, testRunner=HTMLTestRunner(
        output="reports", report_name="hello_report"))

Hola, queria comentar que la libreria webdriver_manager permite que el webdriver se descargue automaticamente, encuentro que es mas versatil que estar descargandolo a la maquina.

Relaciono codigo funcional para windows, no hay necesidad de descargar el webdriver:

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager

class HelloWorld(unittest.TestCase):
    
    @classmethod
    def setUpClass(cls):
        cls.driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
        driver = cls.driver
        driver.implicitly_wait(10)
    
    def test_hello_world(self):
        driver = self.driver
        driver.get('https://www.platzi.com')

    def test_visit_wikipedia(self):
        self.driver.get('https://wikipedia.org')

    @classmethod
    def tearDownClass(cls):
        cls.driver.quit()
    
if __name__ == "__main__":
    unittest.main(verbosity=2, testRunner=HTMLTestRunner(output='reportes', report_name='hello-world-report'))

Hola~~, aquí dejo mi código por si a alguien le sirve, tiene algunos cambios por las actualizaciones, es para Windows

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from selenium.webdriver.chrome.service import Service

class HolaMundo(unittest.TestCase):

    def setUp(self):
        service = Service(executable_path= r'C:\Users\Melissa\OneDrive\Documentos\Selenium\chromedriver_win32\chromedriver.exe')
        self.driver = webdriver.Chrome(service=service)
        self.driver.implicitly_wait(10)
    

    def test_holaMundo(self):
        driver=self.driver
        driver.get("https://www.youtube.com")

    def test_visitWIKI(self):
        self.driver.get("https://es.wikipedia.org/wiki/Wikipedia:Portada")

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

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

para los que realicen el curso desde Windows, Selenium 4.10

<code> 
from selenium.webdriver.chrome.service import Service
from pyunitreport import HTMLTestRunner
from selenium import webdriver
import unittest



class HelloWorld(unittest.TestCase):

		def setUp(cls):
			service = Service(executable_path='C:\\Users\CANVIA\Documents\PERSONAL\CURSO_SELENIUM\chromedriver.exe')
			cls.driver = webdriver.Chrome(service=service)
			driver  = cls.driver
			driver.implicitly_wait(10)


		def test_hello_world(self):
			driver = self.driver
			driver.get('https://www.platzi.com')

		def test_visit_wikipedia(self):
			driver = self.driver
			driver.get('https://es.wikipedia.org')	

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

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

Saludos dejo mis prácticas

import unittest
from selenium import webdriver
from pyunitreport import HTMLTestRunner


class helloworld2(unittest.TestCase):
                    
    def setUp(self):
        self.driver = webdriver.Chrome(executable_path ="./chromedriver")


    def test_Hello_world_argentina_turismo(self):
        self.driver.get("https://www.argentina.tur.ar")
        driver = self.driver
        driver.maximize_window()
        driver.implicitly_wait(10)


    def test_Hello_world_sprach(self):
        self.driver.get("https://www.sprachcaffe.com/sa/espanol/main.htm")
        driver = self.driver
        driver.maximize_window()
        driver.implicitly_wait(10)


    def test_Hello_world_assistcard(self):
        self.driver.get("https://www.assistcard.com/")
        driver = self.driver
        driver.maximize_window()
        driver.implicitly_wait(10)


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

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

import unittest
from selenium import webdriver
from pyunitreport import HTMLTestRunner

class test_helloworld(unittest.TestCase):

    def setUp(self):
        self.driver = webdriver.Chrome(executable_path  ="./chromedriver")


    def test_hello_world_google(self):
        self.driver.get("https://www.google.com/")
        driver = self.driver
        driver.maximize_window()

    def test_hello_world_bing(self):
        self.driver.get("https://www.bing.com/?toWww=1&redig=850D406441AE4277AEED74AE744D8134")
        driver = self.driver
        driver.maximize_window()

    def test_hello_world_platzi(self):
        self.driver.get("https://www.platzi.com/")
        driver = self.driver
        driver.maximize_window()


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

if __name__=="__main__":
    unittest.main(verbosity=2,testRunner = HTMLTestRunner(output = 'reportes', report_name='helloword-practice1'))

Mis notas técnicas:

• Los drivers son un componente de selenium que te inyectan con los browser (chrome, firefox, safari…)
• Estos métodos setUpClass() y tearDownClass() son del framework unittest. La razón por la cual se abre el browser en una misma ventana al ejecutar setUpClass y tearDownClass, en lugar de setUp y tearDown es porque estos tienen el decorador @classmethod, este las convierte en métodos de la clase y no de la instancia, por lo tanto, estos dos métodos se ejecutan una sóla vez para todas las pruebas.

El ejercicio lo corrí en windows 11 y estos fueron los pasos:

1. Dentro del directorio del proyecto cree un entorno virtual e instalé las dependencias

$ virtualenv selenium
$ \selenium\Scripts\activate
$ pip install selenium
$ pip install PyUnitReport
$ pip install webdriver_manager

Mi código quedó así:

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from webdriver_manager.chrome import ChromeDriverManager

class Hello(unittest.TestCase):

    @classmethod
    def setUpClass(cls) -> None:
        cls.driver = webdriver.Chrome(ChromeDriverManager().install())
        driver = cls.driver
        driver.implicitly_wait(10)

    def test_hello(self):
        driver = self.driver
        driver.get("https://www.platzi.com")

    def test_visit_wikipedia(self):
        self.driver.get("https://www.wikipedia.org")

    @classmethod
    def tearDownClass(cls) -> None:
        cls.driver.quit()

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

Compañeros y compañeras que usan WSL2.

Después de 2 semanas buscando el error me di cuenta que NO FUNCIONA EN WSL2.

Ideal cambiar a otra terminal para el proceso.

Espero ayudarle a alguien.

Test Result
Start Time: 2022-09-15 03:43:12

Duration: 6.592s

Status: Pass: 1

reportes Status
test_hello_word (main.HelloWord) Pass
Total Test Runned: 1 Pass: 1

Al principio no me funcionaba, hasta que abri el reporte y me decia que no podia ejecutarse porque mi version de chrome era la 105 y el chromedriver funcionaba para la 106. actualize el chrome y funciono

Nota para todos los que lleguen aqui: No sirve en Ubuntu de consola o algun otro SO que no sea Windows/Mac debido a que esto necesita interfaz grafica para funcionar. Usen Windows por su propio bien.

Att: Mi yo de hace 2 horas intentando solucionar un problema sin solucion.

Si no usas Chrome
Puedes usar Webdriver Manager, que te permite configurar los navegadores Chrome, Chromium, Brave, Firefox, Edge y Opera de forma sencilla. El único detalle que tiene es que deberás instalarlo en la consola de comandos pero es muy fácil de hacer. Te dejo el enlace:
https://pypi.org/project/webdriver-manager/

También puedes consultar la documentación y descargar los Drivers para tenerlos de forma local:
https://pypi.org/project/selenium/
Te comparto mi código donde utilizo Webdriver manager y el navegador Firefox

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from webdriver_manager.firefox import GeckoDriverManager
import time

class HelloWorld(unittest.TestCase):

    # Estas funciones son testfixture
    @classmethod
    def setUpClass(cls):
        """
        SetUp

        Prepara el entorno de la prueba. Ejecuta todo lo necesario antesde comenzar.
        """
        GECKO_DRIVER = GeckoDriverManager().install()
        cls.driver = webdriver.Firefox(executable_path=GECKO_DRIVER)
        cls.driver.implicitly_wait(3)

    def test_hello_world(self):
        """
        Caso de Prueba

        Realiza las acciones automatizadas. En este caso entrar a platzi.com
        """
        driver = self.driver
        driver.get('https://platzi.com')

        # Tiempo de espera de 3 segundos
        time.sleep(3)

    def test_visit_wikipedia(self):
        """
        Caso de Prueba

        Realiza las acciones automatizadas. En este caso entrar a wikipedia.org
        """
        self.driver.get('https:wikipedia.org')
        # Tiempo de espera de 3 segundos
        time.sleep(3)

    @classmethod
    def tearDownClass(cls):
        """
        Acciones para finalizar

        Esto contiene todo lo que hay que hacer o limpiar despues de terminar los casos de prueba.
        """
        cls.driver.quit()


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

Hola a todos!

Se han actualizado algunas librerías y comandos, sobre todo con el driver y con la forma de utilizar find_element… Justo estoy actualizando mis archivos del curso y dejé instrucciones detalladas en el README de mis archivos del curso en GitHub, aquí.

Verifica que ha cambiado y no te desanimes al seguir el curso, hasta el momento, he podido ejecutar todo y lo he actualizado todo en el repositorio de Github; si puedo ayudarte en algo más, avísame. Saludos!

No sé si a alguien le sirva pero yo estoy en Windows con WSL y no me funcionaba me aparecía un error, lo que me salvo la vida fue esto https://www.gregbrisebois.com/posts/chromedriver-in-wsl2/. Espero le pueda ayudar a alguien dure como 2 días intentando solucionarlo para seguir con la clase : )

Bueno a mi me funcionó perfectamente, deben tener en cuenta que la version de chromedriver debe ser compatible con su version de chrome lo mejor es tener la ultima version de chrome y la ultima version del driver, revisen los errores que les entrega el depurador e investiguen yo tuve varios errores pero fueron de tipificacion y tambien tuve errores de impatibilibad del driver y el explorador, exitos.

Hola buenas noches
tuve el mismo problema que la mayoria de los companeros me salia muchos errores cuando ejecutaba el codigo y cuando iva a revisar el report me salia el siguiente error (Mensaje: El ejecutable ‘chromedriver’ debe estar en PATH. Consulte https://chromedriver.chromium.org/home) y en otro computador instale una distribucion de linux para descartar problemas en la conexion de windows y wsl2 y me salia el mismo error y no entendia porque observe varios aportes de los colegas de platzi y nada me sirvio y solo era colocar la ruta me funciono en wsl2 y en la distro de linux completa y listo es muy importatnte tratar de entender los report ejemplo: /home/nombre_del_equipo/Documentos/projects/Python/selenium/chrome_driver/chromedrive
desde Documentos hasta chrome_driver son carpetas en las cuales tengo yo el archivo, prueba todas las soluciones posibles esta simple solucion me demoro 3 dias buscando el error por no entender el report

Buenas noches
en stackOverflow encontre la solucion a mi caso

If you are on windows give path including file name. For example, ‘./chromedriver/chromedriver.exe’ My line of code looks like below.

service = webdriver.chrome.service.Service(’./chromedriver/chromedriver.exe’)
les dejo el Link https://stackoverflow.com/questions/49787327/selenium-on-mac-message-chromedriver-executable-may-have-wrong-permissions

Brave Browser

Si alguien utiliza Brave Browser, les dejo el código que utilicé.

Código

import unittest

from os import path
from pyunitreport import HTMLTestRunner
from selenium import webdriver

CURRENT_PATH = path.dirname(path.abspath(__file__))
DRIVER_PATH = path.join(CURRENT_PATH, 'chromedriver')
BINARY_PATH = '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'

class HelloWorldTestCase(unittest.TestCase):

    @classmethod
    def setUpClass(cls) -> None:
        options = webdriver.ChromeOptions()
        options.binary_location = BINARY_PATH

        cls.driver = webdriver.Chrome(
            executable_path=DRIVER_PATH,
            chrome_options=options,
        )
        cls.driver.implicitly_wait(10)

    def test_hello_world(self):
        self.driver.get('https://platzi.com')

    def test_visit_wikipedia(self):
        self.driver.get('https://www.wikipedia.org')

    @classmethod
    def tearDownClass(cls) -> None:
        cls.driver.quit();


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

Sí tienes WSL2 como yo, este post puede serte muy útil.
How run selenium and Chrome on WSL2

driver (Un objeto de webdriver) puede dirigerse a una dirección en especial con el método .get("https://www.youtube.com/watch?v=Psr4HZmWHnQ")

Para hacer que nuestras pruebas sitio por sitio no cierre el navegador una y otra vez. Solo tenemos que poner el decorador @classmethod sobre nuestros Test Fixture, en el que cambiamos el self, por el cls, en toda la función.

Tenia problemas con el driver de chrome, es mas sencillo instalando la libreria de dirve manager

pip install webdriver-manager

y importar el driver de ejcucion en mi caso es chrome asi que es

from webdriver_manager.chrome import ChromeDriverManager

y al momento de instancia el driver en vez de utilizar la keyword executable_path, aplicar la instancia del driver manager.

  self.driver = 			webdriver.Chrome(ChromeDriverManager().install())

Si tu MacOs dice "“chromedriver” no se puede abrir porque no se puede verificar el desarrollador."
intente esto
xattr -d com.apple.quarantine ./chromedriver

Les comparto mi código, en mi caso estoy usando windows así que lo hice dentro de un entorno virtual (venv)

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver

class HelloWorld(unittest.TestCase):
    @classmethod
    def setUp(cls):
        cls.driver = webdriver.Chrome(executable_path= r'./chromedriver.exe')
        driver = cls.driver
        driver.implicitly_wait(10)
    
    def test_hello_world(cls):
        driver = cls.driver
        driver.get('https://www.platzi.com')

    def test_visit_wikipedia(cls):
        cls.driver.get('https://www.wikipedia.org')

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

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

Para que tu driver se actualice de forma automática usa webdriver-manager.

$ pip install webdriver-manager 

La implementación es la siguiente:

from webdriver_manager.chrome import ChromeDriverManager # Agregas esta linea
cls.driver = webdriver.Chrome(ChromeDriverManager().install()) # Esta linea remplaza a 'cls.driver = webdriver.Chrome(executable_path=r"./chromedriver.exe")'

Mas información en: https://stackoverflow.com/questions/60296873/sessionnotcreatedexception-message-session-not-created-this-version-of-chrome/62127806

Para Windows:
Seguramente existirán algunos problemas con pyunitreport y selenium, para arreglarlos realice lo siguiente:
OBSERVACION: Tomen en cuenta que realice mi instalación de entorno virtual y de los paquetes según lo detalle en la lección pasada.

Si les aparece uno de los 2 errores posibles especificados, tras los cambios es importante cerrar el IDE y entrar nuevamente.

1° Verifiquen que el código sea completamente idéntico al de Héctor.
2° para la dirección el executable tal cual como lo recomienda Hector ejemplo:
r’C://Users/Jesus/venvs/venvpy3.9/selenium/chromedriver.exe’
3° Muy importante que la vuestra carpeta “selenium” la cual es donde guardaremos nuestros archivos, se encuentre dentro de la carpeta en donde se creo el EV(entorno virtual). En mi caso le di por nombre a mi EV “venvpy3.9” y me creo esta carpeta, dentro de ella cree la del proyecto.
4° El archivo chromedriver.exe debe de estar guardado en esta misma carpeta para temas de practicidad.
5° Respecto a la versión de chromedriver.exe descargen la mas actual, posiblemente cuando intenten correr el archivo les marque 2 posibles errores.
Error:** ModuleNotFoundError: No module named ‘pyunitreport’**
El cual solucionaremos con el comando:
pip install -U httprunner --no-cache-dir
Nota: Este comando lo descubrí tras una larga búsqueda, no termino de entender su funcionamiento pleno pero es un tipo de herramienta y lo mas importante me resolvió el error en cuestión.
El** otro error posible** es un error en consola que marca que la versión de Chrome no es compatible con el navegador, solo debes de descargar nuevamente Chromedriver.exe con la versión que te muestra de tu navegador y solucionado.

Si están usando un navegador diferente a Chrome pero esta basado en Chromium, verifiquen la versión que este tiene y descargar la versión de ChromeDriver que lo soporte. Además debe agregar unas lineas de código para que funcioné

from optparse import Option
import unittest
from selenium import webdriver
from pyunitreport import HTMLTestRunner
from selenium.webdriver.chrome.options import Options

class HelloWorld(unittest.TestCase):

    def setUp(self):
        options = Options()
        options.binary_location = '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'
        self.driver = webdriver.Chrome(
            options=options,
            executable_path=r'./chromedriver'
        )
        driver = self.driver
        driver.implicitly_wait(10)

    def test_hello_world(self):
        driver = self.driver
        driver.get('https://www.platzi.com')

    def test_visit_wikipedia(self):
        self.driver.get('https://www.wikipedia.org')

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


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

Ese sería para el caso de MacOS, para Windows es necesario ubicar el binario del navegador en la lista de los programs instalados.

Hola que tal, yo utilizo el navegador Brave Browser y tuve que añadir unas líneas de código más

1.- Importe Options

from selenium.webdriver.chrome.options import Options

2.- Añadí lo siguiente a setUp

    def setUp(self):
        options = Options()
        options.binary_location = '/usr/bin/brave'
        self.driver = webdriver.Chrome(executable_path='./chromedriver', options=options)
        driver = self.driver
        driver.implicitly_wait(10)

Recuerden ver la versión de navegador que tengan, ya que mi caso estaba usando la el chromedrive 86 y tenía instalado mi google chrome en la 85

Para quienes realicen el curso desde windows con WSL2, les recomiendo seguir las instrucciones del artículo que dejo en la parte inferior para tener la configuración previa (chromedriver) para realizar el curso.

• Además, tener en cuenta que se recomienda trabajar desde el home nativo del WSL y evitar usar el /mnt/g/… (etc) - Por cuestiones de rendimiento y porque puede provocar ciertos errores con el webdrive [Nada más que una recomendación, a mí me lanzó muchos problemas al trabajar fuera del home]

• Artículo sugerido: https://cloudbytes.dev/snippets/run-selenium-and-chrome-on-wsl2

Para los que trabajen con macOS y Safari este es el script, no se requiere descargar el WebDriver solo activar la opción de desarrollo
"Permitir automatización remota" de Safari
:

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
import os

class HelloWorld(unittest.TestCase):

@classmethod
def setUp(cls):
    cls.driver = webdriver.Safari()
    driver = cls.driver
    driver.implicitly_wait(10)

def test_hello_world(self):  # caso de prueba
    driver = self.driver
    driver.get("https://www.platzi.com")

def test_visit_wikipedia(self):  # caso de prueba
    driver = self.driver
    driver.get("https://www.wikipedia.org")

@classmethod
def tearDown(cls):
    cls.driver.quit()  # cerrar ventana del navegador

if name == “main”:
unittest.main(verbosity=2, testRunner=HTMLTestRunner(
output=‘reportes’, report_name=‘hello-world-report’))

Solo indicarles que me funciono en windows con python 3.10

adjunto mi codigo

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver

class HelloWorld(unittest.TestCase):
def setUp(self) -> None:
#Ejecuta todo lo necesario antes de hacer una prueba, prepara el entorno de la prueba misma
self.driver = webdriver.Chrome(r’…/chromedriver.exe’)
driver = self.driver
driver.implicitly_wait(10)

def test_hello_world(self):
    #caso de prueba donde se realizarán una serie de acciones para que el navegador las automatice
    driver = self.driver
    driver.get("https://www.google.com")
    

def tearDown(self) -> None:
    #acciones para finalizar
    self.driver.close()

if name == ‘main’:
unittest.main(verbosity=2, testRunner=HTMLTestRunner(output=‘reportes’, report_name=‘hello_world_report’))

hola, si tienes la version 3.10 o 3.11 de Python este es el codigo que me funciono:

import unittest          # Con unittest nos podemos traer todas nuestras pruebas
from pyunitreport import HTMLTestRunner
from selenium import webdriver 

class HelloWorld(unittest.TestCase):

    
    @classmethod  # decorador para que ambos test se muestren en la misma ventana
    def setUpClass(cls) -> None: 
        cls.driver = webdriver.Chrome(r'../chromedriver.exe')
        driver = cls.driver
        driver.implicitly_wait(10) # esperamos 10 seg antes de realizar la  accion
    
    def test_hello_world(self):  
        self.driver.get('https://www.platzi.com') 
    
    def test_facebook(self):
        self.driver.get('https://www.facebook.com') 
    
    @classmethod
    def tearDownClass(cls):
        cls.driver.quit()
    
if __name__ =="__main__":
    unittest.main(verbosity = 2, testRunner = HTMLTestRunner(output = 'reportes', report_name = "hola_report"))

use visual studio code instalando todo lo que nos mostro en la anterior clase, si bien como muchos dicen no hay una explicacion a detalle, no es imposible de hacer, asi que ánimo!

Bueno, este es mi caso, Estoy haciendo el curso usando Windows Subsystem for Linux, allí uso anaconda para los distintos entornos virtuales, uso microsoft edge, ningun aporte me funcionaba, hasta que probe instalando el navegador en wsl, usando los siguientes pasos en la linea de comando:

Primero preparar el entorno para instalar Edge desde la terminal: añadir los siguientes comandos:

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo install -o root -g root -m 644 microsoft.gpg /etc/apt/trusted.gpg.d/
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/edge stable main" > /etc/apt/sources.list.d/microsoft-edge-dev.list'
sudo rm microsoft.gpg

Luego instalar realmente Edge:

sudo apt update && sudo apt install microsoft-edge-stable

por ultimo, este fue mi código, espero a alguien mas le sirva:

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver

class HelloWorld(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Edge(executable_path=r'msedgedriver')
        driver = self.driver
        driver.implicitly_wait(10)

    
    def test_hello_world(self):
        driver = self.driver
        driver.get('https://www.platzi.com')

    def test_visit_wikipedia(self):
        self.driver.get('https://www.wikipedia.org')

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

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

el webdriverde Edge esta en el mismo directorio que el hello_world.py y el que descargue es para linux, no para windows

2023 Ubuntu:

1. Instalar chromedriver

sudo apt-get install chromium-chromedriver 

1. Importar Service desde selenium

from selenium.webdriver.chrome.service import Service

1. Configurar el setUp de la siguiente manera:

def setUp(self):
        chrome = Service(r"/usr/bin/chromedriver")
        self.driver = webdriver.Chrome(service=chrome)
        driver = self.driver
        driver.implicitly_wait(10)

Código completo:

import unittest
from pyunitreport import HTMLTestRunner
from selenium.webdriver.chrome.service import Service
from selenium import webdriver

class HelloWorld(unittest.TestCase):
    
    def setUp(self):
        chrome = Service(r"/usr/bin/chromedriver")
        self.driver = webdriver.Chrome(service=chrome)
        driver = self.driver
        driver.implicitly_wait(10)

    def test_hello_world(self):
        driver = self.driver
        driver.get('<url del sitio a acceder>')

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

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

Por si quieren abrir selenium en google colab les dejo esta liga.

https://sqa.stackexchange.com/questions/2609/running-webdriver-without-opening-actual-browser-window/8723#8723

Que horrible ésta clase

Hola Comunidad

quiero dejar mi pequeño aporte por si a alguien le sirve, dado que, siguiendo lo indicado en el vídeo no me funciono… quiero aclarar que utilice W10 y python version 3.11.1

Espero les funcione como a mi 😃

Actualicen el curso por favor, estoy teniendo muchos problemas al encontrar soluciones para correr este programa, aprendí a usar comandos y utilizar la terminal gracias a los problemas que tuve durante esta practica, pero aun así no eh logrado correrlo, eh checado los comentarios de todos dentro de este video e intentado cada una de las soluciones de los demás y aun así no corre

Falta mucha explicacion por parte del docente para poder comprender realmente como funciona y para que sirve cada cosa que se escribe

A fecha 20/12/2022 el siguiente código para firefox, W11 y con el ambiente virtual creado.

Pasos antes de ejecutar:

1. Tener creado el ambiente virtual con selenium y pyunitreport instalado.
2. Tener descargado el driver adecuado para firefox y ubicado en la carpeta del proyecto con el mismo nombre que se ve en el código.
3. Desde la terminal de VS Code arrancamos el ambiente virtual

Si tenéis algún problema con el ambiente virtual os recomiendo ir a la lección dedicada de este mismo curso y revisar los comentarios.

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver

class HellowWorld(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        self.driver = webdriver.Firefox(executable_path = r'.\geckodriver.exe')
        driver = self.driver
        driver.implicitly_wait(10) #Espera hasta 10 segundos entre accion y accion
    
    
    def test_hello_world(self):
        driver = self.driver
        driver.get('https://platzi.com')

    def test_visit_wikipedia(self):
        self.driver.get('https://wikipedia.org')
    
    #Se ejecuta al finalizar la prueba 
    @classmethod
    def tearDownClass(cls):
        cls.driver.quit() #Cierra la ventana del navegador. Importante para evitar perdida de recursos.

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

exelente explicacion gracias

Los que usan el WSL que te recomiendan en Prework, usen esta pagina para poder instalar selenium:
https://cloudbytes.dev/snippets/run-selenium-and-chrome-on-wsl2

Para las personas que estén cursando este curso y estén utilizando WSL le indico este tutorial para que les sirva de guía en caso de que tengan algún problema de preparar el entorno.

En este caso yo no uso la descarga manual del ChromeDriver, yo uso el siguiente metodo para que desde la ejecuci[on del script me instale el ChromeDriver mas reciente.

La documentación esta en:

https://www.selenium.dev/documentation/webdriver/getting_started/install_drivers/

Desde aquí, como primera opción muestra como obtener siempre el Driver actualizado en cualquiera de los lenguajes admitidos.

A los que usan window mi problema se soluciono modificando lo siguiente:

 def setUp(self):
        self.driver = webdriver.Chrome(executable_path= r'./chromedriver.exe')
        driver = self.driver
        driver.implicitly_wait(100)

el ejecutable le acorte la ruta y tambien actualice chrome a la version mas nueva.

espero les sirva

Hola. lo trabaje con Win10, y solamente he instado las siguientes librerías y no me generó ningún problema.

pip install selenium==4.1.3 
pip install PyUnitReport

Si les sale este error es que no tienen instalado chrome
Message: unknown error: cannot find Chrome binary Stacktrace: Backtrace

lol

• Si sale un error que executable_path está deprecado:

https://stackoverflow.com/questions/64717302/deprecationwarning-executable-path-has-been-deprecated-selenium-python

Tenía mucho entusiasmo en hacer este curso, pero es bastante complicado seguirlo.

Este es el código que me funciona utilizando Ubuntu a la fecha:

Espero sea de ayuda

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver
from selenium.webdriver.chrome.service import Service

class HelloWorld(unittest.TestCase):

    @classmethod 
    def setUpClass(cls):
        service = Service('/usr/bin/chromedriver')
        cls.driver = webdriver.Chrome(service=service)
        driver = cls.driver
        driver.implicitly_wait(10)

    def test_hello_world(self):
        driver = self.driver
        driver.get('https://www.platzi.com')
    
    def test_visit_wikipedia(self):
        driver = self.driver
        driver.get =('https://www.wikipedia.org')

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


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

el executable_path esta deprecado ahora tienes que usar un objeto servicie. Así es como yo logre hacerlo con un el webdriver de edge.

from selenium import webdriver
from selenium.webdriver.chrome.service import Service

class HelloWorld(unittest.TestCase):
	def setUp(self):
		""" 
		Test Fixture
		Metodo que prepara el entorno de la prueba
		"""
		service = Service(r'C:/selenium/msedgedriverx86.exe')
		self.driver = webdriver.Edge(service=service)
		self.driver.implicitly_wait(10)

No me funciona en windows, hice todo paso a paso, si alguien tiene el código en windows, porque ya lo intente y siempre me generar error

(22-Julio-2022) Para quienes tienen problemas con seguir el ejemplo:

Traté de repasar el curso después de años, y las librerías se han actualizado; cuando yo ejecuté mi código después de tanto tiempo, me apareció un DeprecationWarning, pero el test se ejecutó correctamente:

Running tests...
----------------------------------------------------------------------
hello_world.py:13: DeprecationWarning: executable_path has been deprecated, please pass in a Service object
  cls.driver = webdriver.Chrome(executable_path = '../../../../chromedriver/mac64_m1/v103/chromedriver')
 test_hello_world (__main__.HelloWorld) ... OK (11.998555)s
 test_visit_wikipedia (__main__.HelloWorld) ... OK (3.382728)s

Toma en cuenta lo siguiente:

• Yo lo hice con Chrome. Si vas a descargar tu mismo el driver, tu versión de Chrome debe coincidir con la versión del archivo chromedriver que descargues. En mi caso fue la versión 103.0.5 y coloque el archivo chromedriver en una carpeta en la ruta relativa “…/…/…/…/chromedriver/mac64_m1/v103/”. Esto ejecuta bien, pero te da el warning anterior.
• Debes poner mucha atención a los errores o problemas de versión. Si tienes entornos virtuales o múltiples versiones de Python, debes fijarte qué versión se está utilizando con tu programa. Actualiza python, usa pyenv o prueba desde la terminal de VisualStudioCode. Hay muchas formas de probar y tendrás que revisar cuál te funciona.
• Si deseas quitar el warning debes cambiar el código. Toma los consejos de la documentación oficial en este link
• A mí me funcionó lo siguiente al inicio del programa y eliminé así la dependencia del archivo chromedriver:

from webdriver_manager.chrome import ChromeDriverManager

from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService

Y en la función cambie a:

def setUpClass(cls):
        cls.driver = webdriver.Chrome(service=ChromeService(ChromeDriverManager().install()))
        driver = cls.driver

Sigo aprendiendo, pero si puedo ayudarte en algo más, búscame en las redes como fertorresmx

El metodo Setup, es un metodo que se ejecuta antes de cada prueba y el metodo tearDown despues de cada prueba.

En este ejercicio tenes un unico Test: test_hello_world antes de que se ejecute primero se ejecuta el setUp que se esta usando para abrir el navegador, se ejecuta nuestro test que abre platzi y por ultimo el tearDown que manda a cerrar el navegador.

Con python 3.9 en mac os con drive de Firefox:

import unittest
from pyunitreport import HTMLTestRunner
from selenium import webdriver

class HelloWorld(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.driver = webdriver.Firefox(executable_path="/usr/local/bin/geckodriver")

    def test_hello_world(self):
        self.driver.get('https://www.platzi.com')

    def test_visit_wikipedia(self):
        self.driver.get('https://www.wikipedia.com')
		
    @classmethod
    def tearDownClass(cls):
        cls.driver.quit()

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