Configurando Múltiplos Navegadores com Selenium e Python

Índice

Introdução

Setup Inicial
2.1 Clonar o Projeto
2.2 Executar os Testes

Convenções
3.1 Selenium Webdriver
3.2 Headless Browsers
3.3 Reading Inputs

JSON config file

Pytest Fixture

Firefox (GeckoDriver)
6.1 Setup GeckoDriver
6.2 Implementação

Conclusão
7.1 Repositório

Bibliografia

1. Introdução

Esse tutorial é continuação do meu outro tutorial chamado “Selenium Webdriver com Python”.
Por favor, dê uma olhada nele antes de começar esse.

Esse tutorial foi feito com base no curso “Selenium WebDriver with Python”, ministrado por Andrew Knight.
Ele também possui um blog, clique no link para acompanhar as novidades, https://automationpanda.com/.

2. Setup Inicial

Como dito antes, já que esse projeto é uma continuação do tutorial “Selenium Webdriver com Python”, será necessário clonar o repositório dele para continuar o seu trabalho.

2.1 Clonar o Projeto

Antes de começar, verifique se você está clonando a branch correta:
“tutorial/webdriver-with-python”.

Git Repo:
https://github.com/LuizGustavoR/intro-selenium-py/tree/tutorial/webdriver-with-python

Após clonar, verifique no VSCode se a branch clonada foi a correta:

2.2 Executar os Testes

Para ter certeza de que o projeto clonado está realmente funcionando,
abra o “Prompt de Comando” dentro da pasta do projeto.

Execute o comando abaixo:

pipenv run python -m pytest

Você deveria ver essa mensagem:

3. Convenções

3.1 Selenium WebDriver

Como discutido no tutorial anterior, o selenium webdriver suporta múltiplos navegadores:

Nosso projeto está hardcoded para executar apenas os testes no chrome,
Vamos mudar isso.

3.2 Headless Browsers

Headless browsers executam páginas web, mas não renderizam elas visualmente na tela, fazendo com que os testes executem de forma mais eficiente.
Tanto Firefox quanto Chrome tem modos headless.
Você pode executar modo não headless quando desenvolvendo e modos headless quando rodando em um CI.

3.3 Reading Inputs

Exemplos de inputs são urls, nomes de usuários, senhas, parâmetros padrão de timeout.
Precisam de ser enviadas para a automação quando uma suíte de teste começa a ser executada.
Não deveriam ser hardcoded no código da automação, especialmente se são dados sensíveis como senhas.

4. JSON config file

Nesse tutorial você irá utilizar um arquivo json config.
O python consegue parsear um arquivo “.json” em um dicionário em apenas uma linha.

Abra o projeto pelo VSCode e cria o arquivo “config.json” na raiz do projeto:

Preencha o arquivo “config.json” com o código abaixo:

{
    "browser": "Headless Chrome",
    "implicit_wait": 10
}

5. Pytest Fixture

Os parâmetros do arquivo “config.json” serão lidos dentro da fixture pytest.
Abra o arquivo “tests/conftest.py”:

tests/conftest.py

"""
This module contains shared fixture.
"""
 
import json
import pytest
import selenium.webdriver
 
# scope='session' makes
# this fixture run only one time before the entire test suite
@pytest.fixture
def config(scope='session'):
 
    # Read the file
    with open('config.json') as config_file:
        config = json.load(config_file)
 
    # Accept values are acceptable
    assert config['browser'] in ['Firefox', 'Chrome', 'Headless Chrome']
    assert isinstance(config['implicit_wait'], int)
    assert config['implicit wait'] > 0
 
    # Return config so it can be used
    return config
 
# This fixture will run once for each test case
@pytest.fixture
def browser(config):
 
    # Initialize the WebDriver instance
    if config['browser'] == 'Firefox':
        b = selenium.webdriver.Firefox()
    elif config['browser'] == 'Chrome':
        b = selenium.webdriver.Chrome()
    elif config['browser'] == 'Headless Chrome':
        opts = selenium.webdriver.ChromeOptions()
        opts.add_argument('headless')
        opts.add_argument('--log-level=1')
        b = selenium.webdriver.Chrome(options=opts)
    else:
        raise Exception(f'Browser "{config["browser"]}" is not supported')
 
    # Make its calls wait for elements to appear
    b.implicitly_wait(config['implicit_wait'])
 
    # Return the WebDriver instance for the setup
    yield b
 
    # Quit the WebDriver instance for the instance
    B.quit

Obs.: Dentro da opção “Headless Chrome”, o segundo argumento adicionado no setup do “ChromeOptions” foi adicionado para esconder a mensagem exibida pelo selenium webdriver quando o site que está sendo testado bloqueia o rastreamento FLoC.

FLoC é um novo método de rastreamento do Google.

FLoC é ruim para privacidade: Ele coloca você em um grupo baseado no histórico do seu navegador, e qualquer site pode pegar o ID desse grupo FLoC para segmentar e criar uma impressão digital sua.

Para mais informações leia o link (em inglês) abaixo:
Use the DuckDuckGo Extension to Block FLoC, Google’s New Tracking Method in Chrome.

6. Firefox (GeckoDriver)

6.1 Setup GeckoDriver

Para executar os testes no firefox baixe a versão mais nova estável do driver do firefox (GeckoDriver) e extraia o executável na pasta (C:\webdrivers\).

Para baixar o GeckoDriver vá para a página abaixo:
https://github.com/mozilla/geckodriver/tags

Escolhe a versão a versão estável mais nova e clique em “Downloads”:

Depois vá para o fim da página em “Assets” e escolha a versão mais adequada para o seu SO (Windows, Linux, MacOS) e versão do firefox (32 ou 64 bits):

Não se esqueça de extrair o driver dentro da pasta “webdrivers”.

Obs.: Não sabe como configurar esses web drivers nas suas “Variáveis de Ambiente” ?
Vá para o meu outro tutorial e aprenda como: “Instalando ChromeDriver no Windows”.

6.2 Implementação

Abra o arquivo “tests/test_search.py” e faça a asserção “result_page.title()” ser a última.

tests/test_search.py

"""
These tests cover DuckDuckGo searches.
"""
 
from pages.search import DuckDuckGoSearchPage
from pages.result import DuckDuckGoResultPage
 
def test_basic_duckduckgo_search(browser):
    search_page = DuckDuckGoSearchPage(browser)
    result_page = DuckDuckGoResultPage(browser)
    PHRASE = "panda"
   
    # Given the DuckDuckGo home page is displayed
    search_page.load()
   
    # When the user searches for "panda"
    search_page.search(PHRASE)
   
    # And the search result query is "panda"
    assert PHRASE == result_page.search_input_value()
 
    # And the search result links pertain to "panda"
    # for title in result_page.result_link_titles():
    #     assert PHRASE.lower() in title.lower()
 
    # Then the search result title contains "panda"
    assert PHRASE in result_page.title()
 
    # raise Exception("Incomplete Test")

Obs.: Sempre declare asserções “web elements” antes de “page attributes”.
Web Elements têm a espera implícita (implicit wait) configurada para eles, atributos de página (page attributes) não possuem, então se o selenium webdriver ler um atributos de página antes que um navegador mais lento defina um novo valor de atributo (attribute value) o teste irá lançar um erro.

7. Conclusão

Altere o valor do parâmetro “browser” dentro do arquivo “config.json” para o nome do navegador que você quer executar o teste.

{
    "browser": "Chrome",
    "implicit_wait": 10
}

Então execute o comando abaixo no prompt.

pipenv run python -m pytest

Headless Chrome

Chrome

Sucesso.
Parabéns, o teste foi executado como esperado.

7.1 Repositório

Criei uma nova branch para esse tutorial chamada “tutorial/multiple-browsers”, clique no link abaixo para visualizar:
https://github.com/LuizGustavoR/intro-selenium-py/tree/tutorial/multiple-browsers

Fim.