selênio
Selenium
Selenium é um projeto abrangente que encapsula uma variedade de ferramentas e bibliotecas que permitem a automação do navegador web. O Selenium fornece especificamente uma infraestrutura para a especificação W3C WebDriver – uma plataforma e interface de codificação de linguagem neutra compatível com todos os principais navegadores da web.
O projeto é possível graças a colaboradores voluntários que doaram generosamente milhares de horas no desenvolvimento e manutenção de código.
O código-fonte do Selenium está disponível sob a licença Apache 2.0.
Este README é para desenvolvedores interessados em contribuir com o projeto. Para pessoas que desejam começar a usar o Selenium, consulte nosso Manual do usuário para obter exemplos e descrições detalhadas e, se tiver dúvidas, há várias maneiras de obter ajuda.
Leia CONTRIBUTING.md antes de enviar suas solicitações pull.
Estes são os requisitos para criar seu próprio ambiente de desenvolvimento local para contribuir com o Selenium.
Bazelisk, um wrapper do Bazel que baixa automaticamente a versão do Bazel especificada no arquivo .bazelversion e passa de forma transparente por todos os argumentos da linha de comando para o binário real do Bazel.
Java JDK versão 17 ou superior (por exemplo, Java 17 Temurin)
Defina a variável de ambiente JAVA_HOME para o local do executável Java (o JDK, não o JRE)
Para testar isso, tente executar o comando javac . Este comando não existirá se você tiver apenas o JRE instalado. Se você encontrar uma lista de opções de linha de comando, estará fazendo referência ao JDK corretamente.
Xcode incluindo as ferramentas de linha de comando. Instale a versão mais recente usando: xcode-select --install
Rosetta para Apple Silicon Macs. Adicione build --host_platform=//:rosetta ao arquivo .bazelrc.local . Estamos trabalhando para garantir que isso não seja necessário no longo prazo.
Vários anos atrás, Jim Evans publicou um excelente artigo sobre Configurando um ambiente de desenvolvimento Windows para ligações de linguagem Selenium .NET; Este artigo está desatualizado, mas inclui descrições e capturas de tela mais detalhadas que algumas pessoas podem achar úteis.
Este script garantirá um ambiente de desenvolvedor completo e pronto para execução. (nada está instalado ou configurado que já esteja presente, a menos que seja solicitado de outra forma)
Abra o Powershell como administrador
Execute: Set-ExecutionPolicy Bypass -Scope Process -Force para permitir a execução do script no processo
Navegue até o diretório no qual deseja clonar o Selenium ou o diretório pai de um repositório Selenium já clonado
Baixe e execute este script no terminal powershell: [scripts/dev-environment-setup.ps1]`
Permitir a execução de scripts no Selenium em geral:
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned
Ative o modo de desenvolvedor:
reg add "HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionAppModelUnlock" /t REG_DWORD /f /v "AllowDevelopmentWithoutDevLicense" /d "1"
Instale o MSYS2, que é um ambiente shell alternativo que fornece comandos semelhantes ao Unix
Adicione o diretório bin à variável de ambiente PATH (por exemplo, "C:toolsmsys64usrbin" )
Adicione a localização bash.exe como a variável de ambiente BAZEL_SH (por exemplo, "C:toolsmsys64usrbinbash.exe" )
Instale a versão mais recente do Visual Studio Community
Use o instalador do Visual Studio para modificar e adicionar a carga de trabalho "Desenvolvimento de desktop com C++"
Adicione o local do diretório de instalação das ferramentas de compilação do Visual C++ à variável de ambiente BAZEL_VC (por exemplo, "C:Program FilesMicrosoft Visual Studio2022CommunityVC" )
Adicione a versão das ferramentas Visual C++ Build à variável de ambiente BAZEL_VC_FULL_VERSION (isso pode ser descoberto no nome do diretório em "$BAZEL_VCToolsMSVC )
Adicione suporte para nomes de arquivos longos (o bazel tem muitos diretórios aninhados que podem exceder os limites padrão no Windows)
reg add "HKEY_LOCAL_MACHINESOFTWAREMicrosoftCommand Processor" /t REG_DWORD /f /v "DisableUNCCheck" /d "1"reg add "HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlFileSystem" /t REG_DWORD /f /v "LongPathsEnabled" /d "1"
Crie um arquivo selenium/.bazelrc.windows.local
Adicione "startup --output_user_root=C:/tmp" ao arquivo
Permitir que o Bazel crie versões com nomes curtos de caminhos de arquivos longos: fsutil 8dot3name set 0
Defina a saída do bazel como C:/tmp em vez de aninhada no diretório do projeto:
Habilite o suporte a Long Paths com estes 2 comandos de registro:
Se você deseja contribuir com o projeto, mas não deseja configurar seu próprio ambiente de desenvolvimento local, existem duas alternativas disponíveis.
Em vez de criar seu próprio ambiente de desenvolvimento local, o GitPod fornece um ambiente pronto para uso para você.
Como alternativa, você pode construir um Dev Container - basicamente um contêiner docker - adequado para construir e testar o Selenium usando devcontainer.json no diretório .devcontainer. O suporte a IDEs como VS Code ou IntelliJ IDEA deve indicar como tal contêiner pode ser criado.
Você também pode construir uma imagem Docker adequada para construir e testar o Selenium usando o Dockerfile no diretório dev image.
O Selenium é construído usando uma ferramenta de construção comum chamada Bazel, para nos permitir gerenciar facilmente downloads de dependências, gerar binários necessários, construir e lançar pacotes e executar testes; tudo de maneira rápida e eficiente. Para uma discussão mais detalhada, leia o artigo de Simon Stewart sobre Building Selenium
Freqüentemente, agrupamos comandos do Bazel com nosso wrapper Rake personalizado. Eles são executados com o comando ./go .
Os comandos comuns do Bazel são:
bazel build – avalia dependências, compila arquivos de origem e gera arquivos de saída para o destino especificado. É usado para criar binários executáveis, bibliotecas ou outros artefatos.
bazel run – cria o alvo e depois o executa. Normalmente é usado para destinos que produzem binários executáveis.
bazel test – cria e executa o alvo em um contexto com funcionalidade de teste adicional
bazel query – identifica os alvos disponíveis para o caminho fornecido.
Cada módulo que pode ser compilado é definido em um arquivo BUILD.bazel . Para executar o módulo, você se refere a ele começando com // , depois inclui o caminho relativo para o arquivo que o define, depois : e depois o nome do destino. Por exemplo, o alvo para construir o Grid é denominado executable-grid e é definido no arquivo 'selenium/java/src/org/openqa/selenium/grid/BAZEL.build' . Então, para construir a grade, você executaria: bazel build //java/src/org/openqa/selenium/grid:executable-grid .
A documentação do Bazel tem um guia prático para vários atalhos e todas as maneiras de construir vários alvos, que o Selenium faz uso frequente.
Para construir tudo para um determinado idioma:
compilação bazel ///...
Para construir apenas a grade, há um nome alternativo para usar (o log mostrará onde o jar de saída está localizado):
grade de construção do bazel
Para tornar as coisas mais simples, a construção de cada uma das ligações está disponível com este comando ./go
./go:build
A maior parte da equipe usa o Intellij para a edição diária. Se você estiver trabalhando no IntelliJ, é altamente recomendável instalar o plug-in Bazel IJ, que está documentado em seu próprio site.
Para usar o Selenium com o plug-in IntelliJ Bazel, importe o repositório como um projeto Bazel e selecione o arquivo de visualização do projeto no diretório de scripts. ij.bazelproject para Mac/Linux e ij-win.bazelproject para Windows.
Também usamos o Google Java Format para linting, portanto, usar o Google Java Formatter Plugin é útil; existem algumas etapas para fazê-lo funcionar, então leia a documentação de configuração. Há também um script de formatação automática que pode ser executado: ./scripts/format.sh
Embora o Selenium não seja compilado com o Maven, você pode criar e instalar as peças do Selenium para o Maven usar localmente, implantando em seu repositório maven local ( ~/.m2/repository ), usando:
./go java:instalar
As dependências são definidas no arquivo maven_deps.bzl. Para atualizar e fixar automaticamente novas dependências, execute:
./go java: atualização
Você pode executar o código Python localmente atualizando os arquivos gerados no diretório python usando:
./go py: atualização
Para instalar o Selenium localmente com base em um commit específico, você pode usar:
./go py:instalar
Em vez de usar irb , você pode criar um REPL interativo com todas as gemas carregadas usando: bazel run //rb:console
Se você quiser depurar código, você pode fazer isso através do debug gem:
Adicione binding.break ao código onde você deseja que o depurador seja iniciado.
Execute testes com configuração ruby_debug : bazel test --config ruby_debug .
Quando o depurador for iniciado, execute o seguinte em um terminal separado para conectar-se ao depurador:
bazel-selenium/externo/pacote/bin/rdbg -A
Se quiser usar RubyMine para desenvolvimento, você pode configurá-lo usando artefatos do Bazel:
Abra rb/ como diretório principal do projeto.
Execute bundle exec rake update conforme necessário para criar artefatos atualizados. Se isso não funcionar, execute ./go rb:update no diretório selenium (pai).
Em Configurações/Idiomas e Frameworks/Ruby SDK e Gems, adicione um novo intérprete apontando para ../bazel-selenium/external/rules_ruby_dist/dist/bin/ruby .
Agora você deve conseguir executar e depurar qualquer especificação. Ele usa o Chrome por padrão, mas você pode alterá-lo usando variáveis de ambiente especificadas na seção Ruby Testing abaixo.
Para manter Carbo.Bazel.lock sincronizado com Cargo.lock , execute:
CARGO_BAZEL_REPIN = sincronização verdadeira do bazel --only = caixas
Existem várias configurações do Bazel específicas para testes.
Aqui estão alguns exemplos de argumentos que usamos ao testar o código Selenium:
--pin_browsers - executa versões específicas do navegador definidas na compilação (as versões são atualizadas regularmente)
--headless - executa navegadores no modo headless (compatível com Chrome, Edge e Firefox)
--flaky_test_attempts 3 - execute novamente testes com falha até 3 vezes
--local_test_jobs 1 - controla o paralelismo de testes
--cache_test_results=no , -t- - desabilita o cache dos resultados dos testes e executa novamente todos eles
--test_output all – imprime todas as saídas dos testes, não apenas erros
--test_output streamed – executa todos os testes um por um e imprime sua saída imediatamente
--test_env FOO=bar - passa variável de ambiente extra para testar o processo
--run_under="xvfb-run -a" - prefixo a ser inserido antes da execução
Os testes de selênio podem ser filtrados por tamanho:
pequeno — normalmente testes de unidade onde nenhum navegador é aberto
grande – normalmente testes que realmente controlam um navegador
médio – testes que envolvem mais do que testes de unidade simples, mas não conduzem totalmente um navegador
Eles podem ser filtrados usando o argumento test_size_filters como este:
teste bazel ///... --test_size_filters=small
Os testes também podem ser filtrados por tags como:
teste bazel ///... --test_tag_filters=isto,-não-isto
Para executar testes de unidade:
teste bazel //java/... --test_size_filters=small
Para executar testes de integração:
teste bazel //java/... --test_size_filters=medium
Para executar testes de navegador:
teste bazel //java/... --test_size_filters=large --test_tag_filters=
Para executar um teste específico:
teste bazel //java/test/org/openqa/selenium/chrome:ChromeDriverFunctionalTest
Para executar os testes, execute:
teste bazel //javascript/node/selenium-webdriver:testes
Você pode usar --test_env para passar o nome do navegador como SELENIUM_BROWSER .
teste bazel //javascript/node/selenium-webdriver:tests --test_env=SELENIUM_BROWSER=firefox
Execute testes de unidade com:
teste bazel //py:unidade
Para executar testes com um navegador específico:
teste bazel //py:test-
Para executar todos os testes Python:
teste bazel //py:todos
Alvos de teste:
| Comando | Descrição |
|---|---|
bazel test //rb/... | Execute a unidade, todos os testes de integração e lint |
bazel test //rb:lint | Execute o linter RuboCop |
bazel test //rb/spec/... | Execute testes unitários e de integração para todos os navegadores |
bazel test //rb/spec/... --test_size_filters small | Execute testes de unidade |
bazel test //rb/spec/unit/... | Execute testes de unidade |
bazel test //rb/spec/... --test_size_filters large | Execute testes de integração para todos os navegadores |
bazel test //rb/spec/integration/... | Execute testes de integração para todos os navegadores |
bazel test //rb/spec/integration/... --test_tag_filters firefox | Execute testes de integração apenas para Firefox local |
bazel test //rb/spec/integration/... --test_tag_filters firefox-remote | Execute testes de integração apenas para Firefox remoto |
bazel test //rb/spec/integration/... --test_tag_filters firefox,firefox-remote | Execute testes de integração para Firefox local e remoto |
Os destinos de teste Ruby têm o mesmo nome do arquivo de especificação com _spec.rb removido, para que você possa executá-los individualmente. Os alvos dos testes de integração também possuem um navegador e um sufixo remoto para controlar qual navegador escolher e se deve usar o Grid.
| Arquivo de teste | Alvo de teste |
|---|---|
rb/spec/unit/selenium/webdriver/proxy_spec.rb | //rb/spec/unit/selenium/webdriver:proxy |
rb/spec/integration/selenium/webdriver/driver_spec.rb | //rb/spec/integration/selenium/webdriver:driver-chrome |
rb/spec/integration/selenium/webdriver/driver_spec.rb | //rb/spec/integration/selenium/webdriver:driver-chrome-remote |
rb/spec/integration/selenium/webdriver/driver_spec.rb | //rb/spec/integration/selenium/webdriver:driver-firefox |
rb/spec/integration/selenium/webdriver/driver_spec.rb | //rb/spec/integration/selenium/webdriver:driver-firefox-remote |
Navegadores suportados:
chrome
edge
firefox
firefox-beta
ie
safari
safari-preview
Além dos exemplos de opções comuns, aqui estão alguns exemplos específicos de Ruby:
--test_arg "-eTimeouts" - testa apenas especificações cujo nome inclui "Timeouts"
--test_arg " - passa quaisquer argumentos RSpec extras (consulte bazel run @bundle//bin:rspec -- --help )
Variáveis de ambiente suportadas para uso com --test_env :
WD_SPEC_DRIVER - o driver a ser testado; o nome do navegador ou 'remoto' (é definido pelo Bazel)
WD_REMOTE_BROWSER - quando WD_SPEC_DRIVER é remote ; o nome do navegador a ser testado (definido pelo Bazel)
WD_REMOTE_URL - URL de um servidor já em execução para usar em testes remotos
DOWNLOAD_SERVER - quando WD_REMOTE_URL não está definido; se deve baixar e usar a versão do servidor lançada mais recentemente para testes remotos
DEBUG - ativa a depuração detalhada
HEADLESS - para Chrome, Edge e Firefox; executa testes no modo headless
DISABLE_BUILD_CHECK - para cromo e borda; se deve ignorar incompatibilidades de versão do driver e do navegador (permite testar compilações Canary)
CHROME_BINARY - caminho para testar o navegador Chrome específico
CHROMEDRIVER_BINARY - caminho para testar ChromeDriver específico
EDGE_BINARY - caminho para testar o navegador Edge específico
MSEDGEDRIVER_BINARY - caminho para testar msedgedriver específico
FIREFOX_BINARY - caminho para testar o navegador Firefox específico
GECKODRIVER_BINARY - caminho para testar GeckoDriver específico
Para rodar com uma versão específica do Ruby você pode alterar a versão em rb/.ruby-version ou na linha de comando:
echo '' > rb/.ruby-version
Atualmente, os testes .NET funcionam apenas com navegadores fixados, portanto, inclua isso.
Execute todos os testes com:
teste bazel //dotnet/test/common:AllTests --pin_browsers=true
Você pode executar testes específicos especificando o nome da classe:
teste bazel //dotnet/test/common:ElementFindingTest --pin_browsers=true
Se o módulo suportar vários navegadores:
teste bazel //dotnet/test/common:ElementFindingTest-edge --pin_browsers=true
Os testes de ferrugem são executados com:
teste bazel //ferrugem/...
Por padrão, o Bazel executa esses testes na IU atual do servidor X. Se preferir, você pode executá-los alternativamente em um servidor X virtual ou aninhado.
Execute o servidor X Xvfb :99 ou Xnest :99
Execute um gerenciador de janelas, por exemplo, DISPLAY=:99 jwm
Execute os testes de seu interesse:
teste bazel --test_env=DISPLAY=:99 //java/... --test_tag_filters=chrome
Uma maneira fácil de executar testes em um servidor X virtual é usar a funcionalidade --run_under do Bazel:
bazel test --run_under="xvfb-run -a" //java/...
A documentação da API pode ser encontrada aqui:
C#
JavaScript
Java
Pitão
Rubi
Para atualizar a documentação da API para um idioma específico: ./go
Para atualizar toda a documentação: ./go all:docs
Observe que a geração de JavaScript está atualmente interrompida.
O processo completo para fazer um lançamento pode ser encontrado no wiki
A liberação é uma combinação de construção e publicação, que muitas vezes requer coordenação de múltiplas execuções e processamento adicional. Conforme discutido na seção Construção, usamos tarefas Rake com o comando ./go para essas coisas. Esses comandos ./go incluem o argumento --stamp para fornecer as informações necessárias sobre o ativo construído.
Você pode construir e lançar tudo com:
./go all:liberar
Para construir e lançar uma linguagem específica:
./go:release
Se você tiver acesso ao repositório Selenium EngFlow, poderá construir os ativos remotamente e fazer download localmente usando:
./go all:release['--config', 'release']
