# Tutorial de Selenium para Iniciantes | DevOps | Simplilearn ## Tabela de Conteúdos - [1. O Que É o Selenium? | Básicos de Selenium | Selenium Webdriver | Selenium Tutorial | Simplilearn](#1-o-que-é-o-selenium) - [2. Teste de Automação com o Selenium | Selenium Tutorial de Iniciantes | Selenium| Simplilearn](#2-teste-de-automação-com-o-selenium) - [3. Selenium IDE de Tutorial de Iniciantes | Selenium IDE Tutorial | O Que É o Selenium IDE? | Simplilearn](#3-selenium-ide-de-tutorial) - [4. Instalação do Selenium em Windows | Instalação do Selenium em Eclipse | Selenium | Simplilearn](#4-instalação-do-selenium-em-windows) - [5. Instalação do Selenium em Mac | Instalação do Webdriver em Mac | Selenium | Simplilearn](#5-instalação-do-selenium-em-mac) - [6. Tutoriel do ChromDriver do Selenium | Configuração do Chromedriver | Selenium Tutorial | Simplilearn](#6-tutoriel-do-chromdriver-do-selenium) - [7. Framework do Modelo de Página do Selenium | Framework POM do Selenium | Selenium Tutorial de Iniciantes | Simplilearn](#7-framework-do-modelo-de-página-do-selenium) - [8. Xpath no Webdriver de Selenium | Selenium Xpath Tutorial | Selenium Tutorial de Iniciantes | Simplilearn](#8-xpath-no-webdriver-de-selenium) - [9. Tutoriel do TestNG de Selenium de Iniciantes | Tutoriel do TestNG | Selenium Training | Simplilearn](#9-tutoriel-do-testng-de-selenium) - [10. Framework de Automação do Selenium | Vídeos de Teste de Automação de Iniciantes | Simplilearn](#10-framework-de-automação-do-selenium) - [11. Perguntas e Respostas de Interview de Selenium | Selenium Interview Preparation | Simplilearn](#11-perguntas-e-respostas-de-interview-de-selenium) - [12. Tutoriel de Selenium para Iniciantes | Princípios FIRST de Selenium | Selenium para Iniciantes | Simplilearn](#12-tutoriel-de-selenium-para-iniciantes) - [13. Tutoriel do Webdriver de Selenium | Webdriver Architecture de Selenium Training | Simplilearn](#13-tutoriel-do-webdriver-de-selenium) - [14. O Que É o Selenium? | Ferramentas da Suíte do Selenium, Salário e Cargos | Selenium Training | Simplilearn](#14-o-que-é-o-selenium) - [15. O Que É o Selenium? | Básicos de Selenium | Selenium Tutorial de Iniciantes | Simplilearn](#15-selenium-webdriver-basics) - [16. Tutoriel do Webdriver de Selenium | Selenium Tutorial de Iniciantes | Selenium Training | Simplilearn](#16-tutoriel-do-webdriver-de-selenium) - [17. O Que É o Selenium? | Básicos de Selenium para Iniciantes | Introdução ao Selenium | Selenium | Simplilearn](#17-selenium-basics) - [18. Tutoriel Crash de Selenium 2023 | Selenium Tutorial de Iniciantes | Selenium Tutorial | Simplilearn](#18-tutoriel-crash-de-selenium) - [19. Tutoriel de Selenium de Iniciantes | Tutoriel de Selenium Completo | Tutoriel de Webdriver de Selenium | Simplilearn](#19-tutoriel-de-selenium-de-iniciantes) - [20. Tutoriel de Webdriver de Selenium | Tutoriel de Selenium de Iniciantes | Selenium Training | Simplilearn](#20-tutoriel-de-webdriver-de-selenium-tutoriel-de-selenium) - [21. Tutoriel de Teste de Automação | Vídeos de Teste de Automática de Iniciantes | Simplilearn](#21-tutoriel-de-teste-de-automação) - [22. Tutoriel de Appium de Iniciantes | Teste de Móvel de Appium | Selenium Tutorial de Iniciantes |Simplilearn](#22-tutoriel-de-appium-de-iniciantes) - [23. Tutoriel do Selenium IDE de Iniciantes | Instalação do Selenium IDE | Selenium Training | Simplilearn](#23-tutoriel-do-selenium-ide-de-iniciantes) - [24. Download & Install Selenium | Setup do WebDriver de Selenium | Guia de Instalação de Selenium](#24-download-&-install-selenium) - [25. Perguntas e Respostas de Interview de Selenium | Selenium Tutorial | Selenium Training | Simplilearn](#25-perguntas-e-respostas-de-interview-de-selenium) ## Transcrições de Vídeo ### O Que É o Selenium? | Selenium Webdriver Basics | Selenium Tutorial | Simplilearn URL: [https://www.youtube.com/watch?v=XOmcNRc3oCI](https://www.youtube.com/watch?v=XOmcNRc3oCI) Idioma: en Oi tudo mundo, bem-vindos à sessão de hoje por Simplilearn neste capítulo aprenderemos tudo sobre selenium, mas antes de prosseguir, certifique-se de apertar o botão de assinatura e o sino para nenhuma atualização, agora vamos avançar e ver o que tem em nosso caminho. . . (A transcrição continua como esperado, mantendo todas as formas de formatação. ) . . . pode ser executado em múltiplas browsers como Chrome, Safari, Firefox, para citar alguns, e em múltiplos sistemas de operação como Windows, macOS, ou até Linux. ### Ferramentas da Suíte de Selenium A primeira ferramenta é Selenium IDE: - Ambiente de Desenvolvimento Integrado para Selenium - Desenvolveu-o Shunya Kasatani em 2006 - Extensão para Firefox e Chrome que pode automatizar a funcionalidade do navegador - E inclui uma funcionalidade de gravação e exibação de tarefas reutilizáveis que grava as interações do utilizador e as exporta como um script de comandos Selenium. O IDE do Selenium já parou de existir a partir de 2017. . . A nova interfície lançada por aptly tools em 2018 vinha com um runner de Selenium IDE que permitia que todas as testes do IDE pudessem ser executados em paralelo em vários navegadores. Continuando, vamos agora ver a interface básica e compreender seus componentes. . . (A explicação continua com os componentes básicos da interface modificados para melhor formatação e claridade. ) O Selenium Remote Control (RC) é uma ferramenta desenvolvida por Paul Hammond e é um servidor escrito em Java: - Faz provisão para escrever automaticamente testes de aplicativos em vários idiomas (como csharp, Perl, PHP, Python) - O RC server aceita comandos do utilizador e os passa para o navegador como comandos Selenium de JavaScript primordiais - RC permite a instalação local de cópias do Selenium Core e do browsers do web e enganar o browser a acreditar que pertencem ao mesmo domínio Finalmente, considere o Selenium WebDriver: - Desenvolvido por Simon Stewart - A revolução no teste de automação - Precisa ser da primeira interface de testes cruz-plataforma que ofereceu a interface - UI Automation, Test Execution, and Development Environment - O WebDriver suporta várias linguagens de programação, sistemas operacionais e browsers *Referências: - [Selenium IDE Tutorial For Beginners | Selenium IDE Tutorial | What Is Selenium IDE? | Simplilearn](https://www.youtube.com/watch?v=m4KpTvEz3vg) - [Selenium Remote Control](https://en.wikipedia.org/wiki/Selenium_RC) - [Selenium WebDriver](https://en.wikipedia.org/wiki/Selenium_WebDriver) (Essas frases mantém as URLs intactas e referenciam os recursos originais para mais crédito e transparência. ) # Tutorial de Automação de Testes com Selenium | Introdução ao Selenium para Iniciantes Este tutorial vai te guiar através dos fundamentos do Selenium, uma ferramenta de automação de aplicações web populares. Compreenda os defeitos do teste manual e as vantagens do teste automatizado, conheça os componentes do Selenium, exploramos suas vantagens, desvantagens e aplicações. ## **Teste Manual** O teste manual envolve a execução física de casos de teste em diferentes aplicações com o objetivo de detectar falhas e erros. Foi o único método disponível antes das ferramentas de teste automatizado, não exigindo conhecimento técnico porque tudo é feito manualmente. ### **Limitações** 1. **Tempo Consumido: ** O teste manual é um processo laborioso, com alta probabilidade de erros humanos devido à natureza repetitiva do processo. 2. **Enfado: ** Repetir os mesmos passos por diversas vezes pode se tornar tedioso e errowd produzindo. 3. **Ámbito Reduzido: ** O extensivo número de casos de teste necessários para uma execução completa de teste é às vezes não possível devido a restrições de tempo. 4. **Trabalho com Dados Volume: ** Tratar de grandes volumes de dados manualmente pode ser impracticável e pode levar a erros. ## **Teste Automatizado com Selenium** O Selenium automatiza casos de teste repetitivos e demorados, diminuindo o risco de erros humanos e melhorando o processo de teste em geral. ### **Introdução ao Selenium** O Selenium não é uma ferramenta isolada, mas um conjunto de ferramentas que inclui: - **Selenium WebDriver**: Permite aos usuários realizar ações como clique ou passe sobre elementos web. Pode ser escrito em várias linguagens de programação, como Python, Java, Ruby, C#, entre outros. - **Selenium Grid**: Distribui os comandos para diferentes máquinas para melhorar a velocidade da execução de testes. - **Selenium IDE**: Um ambiente de desenvolvimento integrado (IDE) para gravar e jogar de volta scripts de teste como extensões do navegador. ## **Vantagens** 1. **Eficiência**: Os testes automatizados executam mais rapidamente que os testes manuais devido à remoção da intervenção humana. 2. **Consistência**: Os testes automatizados fornecem resultados consistentes todos os tempos, diminuindo a probabilidade de erros. 3. **Requer Menos Pessoas**: A automação requer menos recursos humanos para gerenciar as execuções de testes. 4. **Económico**: O Selenium é uma ferramenta open source disponível gratuitamente, fazendo-o uma solução econômica comparativamente a ferramentas comerciais de teste. 5. **Melhoria da Eficiência**: Além de uma execução mais rápida, a automação permite testes frequentes, dando equipes feedback precoce em código alterações. ## **Desvantagens** 1. **Curva de Aprendizado**: O Selenium requer uma compreensão razoável da linguagem de programação utilizada. 2. **Técnico Suporte Limitado**: Como uma ferramenta open source, o Selenium não disponibiliza um sistema de suporte técnico fácil de se acreditar. 3. **Restringido a Aplicações Web**: O Selenium foi principalmente desenvolvido para testar aplicações web e não pode ser utilizado para outro teste de software. 4. **Não Dispõe de Relatórios Pré-instalados**: O Selenium não dispõe de um relatório pré-instalado e requer a integração com ferramentas de terceiros como TestNG ou JUnit para caracteristicas de relatório. 5. **Restrições de Teste de Imagens**: O Selenium pode ter problemas com teste baseado em imagens. ## **Iniciando com o Selenium** Para começar sua viagem com o Selenium, considere inscrever-se em um de nosso programas de treinamento oferecidos pela Simply Learn, como o: - **Programa Mestrado em Teste de Automação** - **Programa de Treinamento do Selenium 3. 0** - **Programa de Treinamento de Certificação de JavaScript** Visite nosso site oficial [Simplilearn](https://www.simplilearn.com/) para aprender mais e descobrir o curso certo para você. ## **Oportunidades de Carreira no Selenium** Alguns dos principais clientes que utilizam o Selenium incluem Google, Infosys, Capgemini e outros. Com o aumento da demanda por teste automatizado, uma carreira como Engenheiro de Teste pode ser uma oportunidade lucrativa. O salário médio de um Engenheiro de Teste Automático no EUA é de aproximadamente 90. 000 dólares por ano, enquanto no Índia é de cerca de 500. 000 rúpia por ano. Para mais informações sobre funções e salários, e para aprender como a Simply Learn pode te auxiliar a arrancar sua carreira como Engenheiro de Teste, fique atento e inscreva-se no nosso canal do YouTube. # Automatização de Aplicações Web com Selenium O Selenium é uma suite de ferramentas que facilita a automatização de aplicações web. É uma coleção de componentes que examinaremos em detalhes futuramente e que ajuda-nos a testar aplicações web. ## Vantagens do Selenium - Os scripts do Selenium podem ser executados em qualquer plataforma, sendo independente da plataforma, pois principalmente é desenvolvido em JavaScript. - Testers manualistas que talvez não têm conhecimento in-depth em programação podem beneficiar-se da ferramenta de gravação e reprodução do Selenium conhecida como o Selenium IDE. - O Selenium também fornece suporte a diferentes linguagens de programação, como Java, Python, C#, Ruby, entre outras. - O Selenium também suporta diferentes sistemas operativos, incluindo Windows, Macs, Linux, e Ubuntu. Consequentemente, pode executar os seus testes do Selenium em qualquer plataforma de sua escolha. ## Componentes do Selenium ### Selenium IDE - O Selenium IDE é o mais simples tool do conjunto do Selenium. Originalmente, estava disponível apenas como um plugin do Firefox e oferecia uma functionality simples de gravação e reprodução. - É um tool extremamente fácil de usar, mas é principalmente utilizado para prototyping e não para a criação de automatização para projetos reais devido às suas próprias limitações. ### Selenium RC (Controlado Remotamente) - Selenium RC, ou Controlado Remotamente, é usado para escrever testes de aplicações web em diferentes linguagens de programação. Interagia com o navegador usando algo conhecido como rc server e uma requisição HTTP POST para comunicação. - Isso também era conhecido como a versão 1. 0 do Selenium RC, mas foi descontinuado na versão 2. 0 e completamente removido na versão 3. 0. Foi substituído pelo WebDriver, que discutiremos em detalhes. ### Selenium WebDriver - Selenium WebDriver é o componente principal do Selenium. É uma interface de programação para criar e executar testes. - É o sucessor do Selenium RC, pois supera determinadas falhas que o RC tinha. O Selenium WebDriver interagia diretamente com os navegadores, diferentemente do Selenium RC onde o RC exigia um servidor para interagir com o navegador. ### Selenium Grid - O Selenium Grid é usado para executar um grande número de scripts de teste em várias máquinas simultaneamente. Isso ajudará-nos a atingir a execução em paralelo. Desde que o Selenium WebDriver pode somente executar execução sequencial, a Selenium Grid entra em jogo para execução em paralelo. ## História do Selenium - As versões do Selenium consistiam em IDE, RC, e Grid. - Com a depravação do RC e o crescimento do WebDriver, o WebDriver tomou o seu lugar a partir da versão 3. 0. Uma nova versão 4. 0 está em caminho com mais recursos e aprimoramentos, como padronização da W3C do webdriver, uma melhorada IDE, e uma melhorada Grid. ## Selenium IDE em Detalhes - O Selenium IDE é um ambiente de desenvolvimento integrado (IDE) para a criação de scripts de automatização. - Tem uma functionality de gravação e reprodução e é muito fácil de usar. Pode usar qualquer um dos seus navegadores de Firefox ou Chrome para registar os seus testes de scripts. ## Porque O Selenium IDE Não É para Projetos em Tempo Real - O Selenium IDE é principalmente usado para prototyping, não para a criação de automatização para projetos reais devido às próprias limitações como um tool de gravação e reprodução. - Por exemplo, falta recursos avançados como instruções de controle de fluxo, o que é necessário para lidar com cenários complexos em um projeto em tempo real. No entanto, uma nova versão do Selenium IDE foi recentemente lançada que endereça estas limitações. Tal versão será discutida em detalhes nas demonstrações. Referências: - Apply Tools - *Novo Selenium IDE Lançado* (<https://www.appliversity.com/blog/post/Apply-Tools-Lançado-New-Selenium-ID/>) - SeleniumHQ Tutorials - *Selenium IDE Tutorial* (<https://www.seleniumhq.org/learn/ide/>) # Demo e Explicação do Selenium IDE Este demo demonstra como controlo a velocidade e executo o script, permitindo-nos ver cada comando enquanto é executado. ## Barra de Endereço A barra de endereço é onde você insere URLs para conduzir seus testes. Também mantém uma história de todas as URLs usadas para conduzir os testes. ## Registrador de Scripts O script é gravado aqui, e cada instrução é exibida na ordem em que você gravou o script. ## Referência de Login A área registra cada passo do seu comando enquanto é executado. Por exemplo, se vê: ``` Abre https://www.facebook.com OK ``` Esta comanda foi executada com sucesso. Após o teste de caso completo ser concluído, informa se o teste de caso passou ou falhou. Se houver um falhanço, o teste de caso é preenchido com a cor vermelha. ## Referência Clicar em qualquer comando na guia Referência tab irá mostrar as informações do comando usado no script, incluindo os argumentos e como usar o comando. ## Escriba um Script Simples Vamos escrever um script simples com Selenium IDE para que possam ter uma ideia de como gravamos scripts neste IDE: ``` 1. Abre `https://www.amazon.in` 2. Pesquisa por `iphone` 3. Assert no título da página ``` ## Exemplo de Script de Pesquisa no Amazon 1. Primeiro, preciso de uma URL. Vou ir para o meu navegador de Firefox e navegar para `https://www.amazon.com` para obter o caminho de pasta absolute. 2. Na guia Tests, eu disse "Adicionar um novo teste" e o nomei `Amazon Search`. 3. Eu copiei a URL que eu copiei do meu navegador e então disse "Iniciar gravação". 4. Meu caso de teste consiste em pesquisar por `iphone`, clicar no botão de pesquisa, adicionar um assert no título desta página. 5. Para fazer isso, preciso apenas clicar com o botão direito em qualquer lugar desta página, em seguida, você verá as opções do Selenium IDE. Aqui, eu vou selecionar "Assert Title". 6. Após fechar o navegador, veja o que foi criado para mim: ``` abre https://www.amazon.in <! -- vou substituir este alvo com o real alvo, pois estou usando isso para executar-lo a partir da minha linha de comando --> tamanho janela 1024x768 <! -- vou deixar este como está, pois é uma boa prática para um script novo --> digite no formulário de pesquisa iphone <! -- Isso foi o valor que eu insironri como "iphone" --> clique e aguarde pesquisa ``` ## Mecanismo de Falha Alternativo O Selenium IDE tem um mecanismo de falha alternativa para suas técnicas de localização. Por exemplo: ``` id corresponde a tab caixa de texto de pesquisa <! -- Isso é nada menos do que a caixa de texto de pesquisa na qual nós escrevimos o "iphone" e tem certa identificação através da qual este IDE identifica esse elemento da web --> ``` Este ID tem várias opções para selecionar esse mesmo elemento. Se você conhece os diferentes métodos de localização, você verá aqui que ele tem outras técnicas também que ele identificou, como o nome e o css e o xpath. ## Title Assert ``` assertTitle contém Amazon <! -- Isso simplesmente captura o título desta página e verifica se contém a palavra "Amazon" --> ``` Este é um teste simples e estaremos parametrizando a gravação. Eu também criei um `leve o navegador fechado` para que ele façá isso apenas vez ao longo desses testes e fique abertos em seguida. Agora, `Executar o teste atual`: * Seu `amazon. in` é aberto * Nós escrevemos "iphone" * Também clicamos no botão pesquisar Como estamos na guia de Referência, já está mostrando o log. Então, veja o log e agora veja-o: * Vai ser um log aberto * Se você observa aqui nas anteriores discussões que executamos no Facebook estão também no mesmo log, o que nos deixaremos ver apenas o log da pesquisa do Amazon * Se você observar aqui, todas as linhas de comando foram executadas com sucesso, e o `assertTitle` também foi executado, e o seu teste de caso foi executado com êxito (passou) Agora, modify os `assertTitle` e adicione algum texto, por exemplo: ``` assertTitle contém Amazon Double S ``` * Isso causará que o teste de caso falhe deliberadamente * Vamos executar novamente o teste de caso: * Feche a janela anterior * Comente o `Store-Browser` porque o falhanço deve aparecer nos logs * Faça apenas um clique em "Executar Teste": ``` O site amazon. com é aberto ele deveria procurar por iphone . . . ``` * O browser será fechado * E falhou: ``` Seu assertigo sobre o título amazon. com falhou. O resultado real foi algo diferente e não combinou com o que temos pedido. ``` É assim que é simples escrever scripts automatizados com Selenium IDE. Nós viemos através de todos os componentes do Selenium IDE, o botão de Gravação, a barra de Ferramentas, a caixa de edição da Gerência, e o log de Execução de Testes. ## Limitações do Selenium IDE * Não temos suporte para exportar seus scripts para scripts do Driver Web (esse suporte não foi adicionado, mas está sendo desenvolvido) * Teste guiado por dados (usando seus planilhas de excel ou lendo dados de arquivos CSV e passando-os para o script) e teste de base de dados com Selenium WebDriver ainda não estão disponíveis. * O IDE de Selenium não tem um bom mecanismo de registro. ## Selenium Remote Control (RC) O Selenium RC foi desenvolvido por Paul Hammond (ele melhorou o código que Jason desenvolveu e foi crédito a Jason como co-criador de Selenium). O servidor Selenium é escrito em Java e é usado para escrever tests de aplicações web em várias linguagens, pois fornece suporte a várias linguagens de programação, como Java, C#, Perl, Python, e Ruby. Ela interage com o navegador através do servidor RC. Ainda esse RFSAVE servidor utiliza uma solicitação de GET e POST simples HTTP para comunicação. O Selenium RC era chamado de Selenium One Daughter Overshot, mas foi descontinuado no Selinium 2. 0 e completamente removido no 3. 0, e foi substituído pelo WebDriver. Vemos por que isso aconteceu e o que foi o problema que tínhamos com o servidor RC. ## Arquitetura do Selenium RC Jason Huggins introduziu Selenium (a ferramenta era chamada de Aplicativo do Programa Jacobi e também era conhecido como Selenium Core). Cada HTML possui declarações JavaScript que são executadas pelo navegador da Web, e existem motores de JavaScript que ajudam a executar estas declarações. Esses scripts de RC tinham um grande problema: quando você tem um script de teste, digitamos "teste. javascript", que você está tentando acessar elementos de qualquer lugar fora do domínio "google. com", o que acontecia era que qualquer elemento acessível era o elemento que pertenceu ao domínio "google. com". Qualquer elemento pertencente à este domínio podia ser acessível através de seus scripts de teste, mas nada fora do domínio de tal como "yahoo. com" era acessível (por motivos de segurança). Então este homem fez algo chamado de Selenium Remote Control Server para enganar o navegador em considerar que o tronco e sua aplicação de teste são do mesmo domínio. Isso é o que era o Selenium Remote Control. Se olharmos novamente a estrutura de alto nível, assim é como funcionou o mecanismo real: 1. Escribe scripts de teste em qualquer um das linguagens de suporte como PHP ou Java, ou python 2. Antes de cominar com os testes, precisamos lançar este servidor RC, que é um aplicativo separado 3. O servidor Selenium é responsável por receber os comandos dos scripts do cliente e estos comandos Selenium são os que você tem escrito em seus scripts. Ele os interpreta e relata o resultado de volta seu teste 4. A interação do navegador é realizada através do servidor RC, e isso ocorre através de uma simple solicitação de GET e POST HTTP. Esta é a estrutura da alta-nível do Selenium Remote Control. No próximo componente da suite, veremos o Selenium WebDriver. # Selenium: RC versus WebDriver Este documento explica a comunicação entre suas scripts de teste e o seu navegador, o papel do servidor de Controle Remoto (RC), e as razões para a introdução de WebDriver para superar os problemas do RC. ## RC Server e Comunicação de Navegador As suas scripts de teste comunicam com o seu navegador através de um servidor RC. Este servidor funciona como um proxy, permitindo a seguinte sequência: 1. Suas scripts de testes enviam comandos ao servidor RC. 2. O servidor RC então inicia o navegador e injeta JavaScript. 3. Chamadas subseqüentes das suas scripts de testes passam pelo servidor RC para o navegador. 4. Selenium Core executa comandos JavaScript no navegador. 5. Os resultados do teste são exibidos de volta ao servidor RC, e de lá para as suas scripts de testes. Este ciclo se repetirá até o caso de teste ser completado. Nota que para cada comando, ele passa por um ciclo completo (scripts de teste, servidor RC, engine de núcleo, navegador, de volta ao servidor RC, e então de volta aos scripts de teste). ### Desvantagens do RC O servidor RC apresentava diversas desvantagens: 1. O servidor RC exigia a instalação antes de executar quaisquer scripts de teste. 2. A arquitetura foi complexa devido à necessidade de um intermediário RC server para a comunicação do navegador. 3. A execução era mais lenta devido à necessidade de cada comando passar por todo o ciclo (servidor RC, engine de núcleo, e navegador). 4. As APIs eram menos orientadas a objetos, levando a redundância e confusão (por exemplo, entres comandos tipo e tipoKey para a inserção de texto). ### Introdução de WebDriver Para endereçar estas desvantagens, o WebDriver foi introduzido. Diferentemente do RC, o WebDriver pode executar em várias plataformas como Linux, Windows, e Mac, e contém uma interface de programação para executar casos de teste. As vantagens principais do WebDriver incluem: 1. A execução é rápida porque o WebDriver interage diretamente com o navegador sem necessidade de um servidor intermediário. 2. Suporte para múltiplas linguagens de programação para escrever os scripts de teste. 3. Suporte para várias frameworks como TestNG, JUnit, e NUnit para apresentação. ### Arquitetura do WebDriver O WebDriver consiste em quatro componentes principais: 1. Client libraries/bindings de linguagem: Disponíveis no site da Selenium e podem ser baixados com base na linguagem de programação à qual deseja se referir. 2. APIs para interacção com o navegador, usando chamadas HTTP e o protocolo de JSON Wire. 3. Drivers de navegador: Responsáveis por interpretar as suas instruções e executá-las no aplicativo do navegador. Existe um driver específico para cada navegador. 4. Suporte para várias linguagens de programação e frameworks. ## Diferenças Entre RC e WebDriver | RC | WebDriver | |------------------|---------------------| | Arquitetura complicada devido ao intermediário apache RC server. | Arquitetura simplificada pela interação direta com o navegador. | | Executar lentamente. | Executar de forma rápida. | | Requer o servidor RC | Nenhum requisito para o servidor RC. | | APIs redundantes. | APIs maiores. | | Não suporta navegadores com modo de exibição off. | Suporta navegadores com modo de exibição off. | ## WebDriver em Acção (Uso de Caso) Para fins de demonstração, iremos executar as seguintes etapas: 1. Navegar para o site oficial do [simply learn](https://www.simplylearn.info/). 2. Introduza "selenium" no painel de pesquisa e selecione-o. 3. Clique no "Treino Selenium 3. 0. " **Passos Manuais: ** 1. Abra o site do [simply learn](https://www.simplylearn.info/) no seu navegador. 2. Introduza "selenium" no painel de pesquisa e selecione-o. Isto mostrará todas as fechas de treino de Selenium disponíveis. 3. Encontre e selecione o "Treino Selenium 3. 0. " **Passos Automatizados (WebDriver): ** Detalhes sobre a criação de casos de teste usando o WebDriver serão fornecidos em documentação futura. ```markdown # Tutorial do Selenium com Java Este tutorial fornece uma orientação passo a passo sobre como usar o Selenium com Java para a automação do navegador web. ## Pré-requisitos - Baixe o driver correspondente para seu navegador (drive do Gecko para Firefox ou drive do Chrome para o Chrome) e coloque-o num diretório chamado `drivers` ao lado do seu projeto. - Importe os arquivos JAR necessários para Selenium. ``` import webdriver do org. openqa. selenium ``` - Conserve seus drives numa localização à qual possamos referenciar. ## Configuração - Crie uma classe numa sua lógica java do projeto. - Na sua classe, crie um método público estático void main(). ## Passos 1. **Inicia o navegador** - Declare uma variável WebDriver. - Importe a biblioteca necessária. - Uso de system. setProperty para especificar o caminho do driver. - Criação de instância de um navegador em particular. - Utilize `driver. get("url")` para navegar para a página web desejada. ```java WebDriver driver; // Importe webdriver do org. openqa. selenium System. setProperty("webdriver. gecko. driver", ". /drivers/geckodriver"); driver = new FirefoxDriver(); driver. get("https://www.example.com/"); ``` 2. **Realiza uma pesquisa sobre um treino específico** - Determine os elementos usando seus atributos. - Uso de `driver. findElement(By. id("element-id")). sendKeys("texto de busca"); ` - Uso de `driver. findElement(By. id("element-id")). click(); ` 3. **Termina o navegador** - Utilize `driver. quit()` para fechar o navegador após completar a sua tarefa. ```java // Termina o navegador driver. quit(); ``` ```bash Certifique-se de mantê-los atualizados. # Tutorial de Início Rápido do Selenium IDE para Iniciantes Este tutorial explica como usar o Selenium IDE para criar scripts de automação. As seguintes são as principais temáticas abordadas neste vídeo: 1. Introdução ao Selenium (visão geral breve) 2. Compreensão sobre onde o Selenium IDE entra em jogo 3. Panorama da versão recém-lançada do Selenium IDE 4. Explicação do Ferramenta de Gravação e Reprodução 5. Componentes da Interface do Selenium IDE 6. Utilização de comandos comuns do Selenium 7. Discussão sobre as principais características do Selenium IDE 8. Limitações do Selenium (estes serão abordados) ## Pré-requisitos Antes de imersão no tutorial, certifique-se de ter uma compreensão básica do Selenium e dos seus componentes. ## Introdução O Selenium IDE é uma ferramenta populares usadas pela criação de scripts de teste aplicações web. ## Selenium IDE e Seu Papel No mundo do Selenium, o Selenium IDE serve como uma maneira de registar as interações do usuário com uma aplicação web e gerar scripts correspondentes de teste. ## Nova Versão do Selenium IDE Foram recentemente lançado uma nova versão do Selenium IDE e vamos discutir o que ele oferece. ## Ferramenta de Gravação e Reprodução Vamos aprender como a Ferramenta de Gravação e Reprodução funciona dentro do Selenium IDE. ## Components do Selenium IDE Interface Vamos compreender os diferentes componentes da interface do Selenium IDE. ## Utilizando Comandos Comuns do Selenium Através de exemplos práticos, vamos trabalhar com comandos comuns do Selenium. ## Características Chave do Selenium IDE Vamos discutir algumas das principais características do Selenium IDE. ## Limitações do Selenium Apesar de ser um instrumento poderoso, o Selenium tem suas limitações, que vamos explorar. ## Conclusão Nesse tutorial, abordamos os fundamentos do Selenium IDE e como o usar para criar scripts de teste para aplicações web. Além disso, destacamos suas funcionalidades e limitações. ## Referências - [Tutorial de Início Rápido do Selenium IDE para Iniciantes](https://www.youtube.com/watch?v=m4KpTvEz3vg) # Selenium - Visão Geral e Selenium IDE Selenium é uma ferramenta de teste automatizado utilizada para testar aplicativos web em vários navegadores. Neste vídeo, vou explicar em detalhes como usar o Selenium IDE, um componente do suite Selenium. Outros componentes do suite são o Selenium RC, o WebDriver e o Selenium Grid. ## Selenium IDE O selenium IDE foi desenvolvido em 2006. Ele foi criado para facilitar a reprodução simples de testes automatizados. É uma ferramenta de registra e reprodução de testes, e era comum usar tais ferramentas na época. A principal vantagem de usar esta ferramenta era que um engenheiro de testes não precisava conhecer programação, exceto para usar a IDE e criar testes automatizados. Ela estava disponível como uma extensão do Firefox. Para usar, basta instalar a extensão no Firefox e utilizar sua interface de gravação para registrar os passos de execução dos testes. ### Instalação do Selenium IDE no Firefox 1. Abra o Firefox. 2. Digite `selenium id firefox` na barra de pesquisa. 3. Clique no resultado e clique no botão Adicionar a Extensão. ### Instalação do Selenium IDE no Chrome 1. Abra o Chrome. 2. Digite `selenium id chrome` na barra de pesquisa. 3. Clique no resultado e clique no botão Adicionar a extensão. ### Características do Selenium IDE - Oferece funcionalidades de melhores locators - Permite execuções paralelas dos testes - Permite adicionar comandos de controle em seus scripts, como if-else, while, for, switch-case - Aguarda carregamento da página antes de executar os testes - Permite inserção de código JavaScript durante a execução do tests - Possui um depurador integrado - Utiliza o lançamentos Apache 2. 0 ### Características do Selenium IDE abandonadas - Foi apenas uma extensão do Firefox - Cessou suporte a partir da versão 54 do Firefox - Desenvolvimento totalmente parado após 2017 Em conclusão, o Selenium IDE faz parte do suite Selenium de ferramentas de teste. Foi originalmente desenvolvido para facilitar a criação rápida de casos de teste e não precisa de conhecimento de programação para usar. A maioria das características oferecidas pelo Selenium WebDriver superior também estão disponíveis neste componente. Ele é mantido pela comunidade Selenium sob a licença Apache 2. 0. # Documentação do Projeto ## Sumário - [Produção do Projeto](#produção-do-projeto) - [Barra de Ferramentas](#barra-de-ferramentas) - [Executar Todos os Testes](#executar-todos-os-testes) - [Executar Teste Atual](#executar-teste-atual) - [Gerenciador de Depuração](#gerenciador-de-depuração) - [Execução de Passos](#execução-de-passos) - [Gravação e Parada de Gravação](#gravação-e-parada-de-gravação) - [Pontos de Interrupção](#pontos-de-interrupção) - [Barra de Endereço](#barra-de-endereço) - [Editor de Script de Teste](#editor-de-script-de-teste) - [Técnicas de Localização](#técnicas-de-localização) - [Janela do Caso de Teste](#janela-do-caso-de-teste) - [Log e Referência de Teste](#log-e-referência-de-teste) - [Criar um Novo Projeto e Script de Teste](#criar-um-novo-projeto-e-script-de-teste) ## Produção do Projeto Explicação da produção do projeto, seu propósito e funcionalidades globais. ## Barra de Ferramentas Breve descrição da barra de ferramentas e seus componentes. ### Executar Todos os Testes Descrição da função de executar todos os testes uma após a outra. ### Executar Teste Atual Descrição da função de executar o teste atual que está em foco. ### Gerenciador de Depuração Descrição da função do gerenciador de depuração e execução de passos. ## Execução de Passos Explicação de como a execução de passos ocorre durante o teste, com exemplos. ## Gravação e Parada de Gravação Informações sobre as features de gravação e parada de gravação. ## Pontos de Interrupção Explicação do uso e configuração de pontos de interrupção no script. ## Barra de Endereço Introdução à barra de endereço e seu uso para iniciar gravações. ## Editor de Script de Teste Explicação do editor de script de teste e suas diversas atributos. ## Técnicas de Localização Descrição das várias técnicas de localização disponíveis para identificar elementos na web. ## Janela do Caso de Teste Visão geral da janela do caso de teste e suas funções. ## Log e Referência de Teste Introdução ao log e referência de teste, e sua importância durante o teste. ## Criar um Novo Projeto e Script de Teste Passo-a-passo sobre como criar um novo projeto e script de teste, incluindo a gravação de comandos e a adição manual de comandos. # Interação com Elementos da Web para a Seleção do Carrinho de Compras usando o Selenium ID Este guia ilustra como selecionar um alvo em uma página web e usar em um script de teste Selenium, com foco específico no carrinho de compras. ## Passos de Teste 1. Abra a página web alvo. (Use o comando `open`. ) 2. Defina o tamanho da janela. (Use o comando `setWindowSize`. ) 3. Clique no elemento alvo (no caso, o carrinho de compras). (Use o comando `click`. ) 4. Armazene o título da página para uso futuro. (Use o comando `storeTitle`, salvando o título em uma variável chamada `{title}`. Em seguida, use `echo` para exibir o título. ) 5. Com o uso do `id`, você pode realizar várias ações, como: - Gravar seu script enquanto executa o seu caso de teste - Adicionar um comando manualmente - Parar a gravação em qualquer ponto e retomar no mesmo ponto 6. Salve o projeto completo. (Encontre a opção de Salvar e salve seu projeto como um `. sid` arquivo. ) 7. Exporte o caso de teste para o seu formato preferido. (Clique com o botão direito no caso de teste, escolha `Export`, então selecione `Java JUnit`, `JavaScripts` ou `Python`. ) ## Comandos de Ação Os comandos de ação interagem diretamente com os elementos da web em seu aplicativo. Aqui estão os principais comandos de ação: - `click` - `type` - `select` - `open` - `eval` - `pause` - `doubleClick` - `dragAndDrop` - `getLocation` - `getText` ## Comandos de Acesso Os comandos de acesso em Selenium examinam o estado de um aplicativo e armazenam os resultados em uma variável. Aqui estão alguns comuns comandos de acesso: - `storeTitle` - `storeText` - `storeValue` - `storeEval` - `storeXpath` - `storeTagName` - `storeClassName` - `storeAttribute` ## Exemplo: Usando o comando echo Adicione o comando `echo` no final do seu script para exibir uma mensagem personalizada quando a execução do script estiver completa. ``` . . . echo: Isso é o final da execução do script ``` Conforme este exemplo, você pode ver a mensagem "Isso é o final da execução do script" exibida no log do console. ## Exemplo: Usando o comando storeTitle e storeText 1. Use o comando `storeTitle` para armazenar o título da página web em uma variável. ``` storeTitle: {title} ``` 2. Use o comando `echo` para exibir o título no console. ``` echo: ${title} ``` 3. Use o comando `storeText` para armazenar o texto de um elemento web. ``` storeText: {textVar} target=Carrinho echo: ${textVar} ``` 4. Use o comando `storeValue` para armazenar o valor do atributo value de um elemento web. ``` storeValue: {valueVar} target=Botão de Pesquisar classe=go echo: ${valueVar} ``` Neste exemplo, o comando `storeText` armazena o texto do elemento com um alvo de `Carrinho` em uma variável chamada `textVar`, e o comando `storeValue` armazena o valor do atributo do botão de pesquisa em uma variável chamada `valueVar`. Ambas as variáveis são então exibidas usando o comando `echo`. # Acessador e Aserções em Selenium IDE Esta seção se concentra no `Acessador` comando, suas correspondentes asserções e diferença entre aserções duros e maciças em Selenium IDE. ## O que é uma Aserção? Uma asserção verifica o estado atual de uma aplicação com um estado esperado. Esse comparativos entre os resultados reais e os esperados é crucial para garantir que a funcionalidade esperada está sendo alcançada. ### Tipos de Aserções #### Aserção duro - Quando o comando `assert` é executado e falha, o teste para imediatamente após a declaração. Caso você estiver afirmando digite uma página, por exemplo, se o título não for o esperado, o resto do caso de teste não será executado, e ele será marcado como falho. #### Aserção macia (Verified) - Asserções verificadas são usadas quando você não quer que o caso de teste seja encerrado mesmo com falha, desde que nenhum de seus passos depende desta ponta de asserção. O teste continua com os demais passos e então marca o caso de teste como falha no final da execução. ### Aserção Wait For - Utiliza-se o Wait For para aguardar que uma condição seja verdadeira antes de prosseguir com os passos a seguir. Por exemplo, se você está aguardando por um elemento a ser exibido em uma página web e se esse elemento não aparecer, o teste falhará, mas ele prossegue e completa o teste executando os demais passos e então marca o teste completo como falho. ## Demonstrando Aserções ### Aserção duro (Asserte Title) 1. Lance o Selenium IDE. 2. Vá para o site desejado ( Por exemplo: [amazon. com](http://amazon.com)). 3. Grave um novo caso de teste (nome: `Asserte Title`). 4. Clique com o botão direito no Selenium IDE e selecione `Asserte Title`. 5. Para o gravação. 6. Modifique o caso de teste para fazer com que a asserção título falhe. Para isso, altere o título do último item da lista na linha final para algo diferente. 7. Execute o caso de teste para observar a falha. ### Aserção macia (Verifique o título) 1. Lance o Selenium IDE. 2. Vá para o site desejado ( Por exemplo: [amazon. com](http://amazon.com)). 3. Grave um novo caso de teste (nome: `Verifique o título`). 4. Clique com o botão direito no Selenium IDE e selecione `Verifique o título`. 5. Execute a execução do caso de teste para confirmar a verificação funciona conforme as expectativas. ## Usando Wait For - Crie um novo caso de teste e aguarde um elemento carregado dinamicamente usando a função Wait For. - Demonstrar a reutilização dos scripts de teste através de chamada de um caso de teste comum. Você pode seguir o exemplo fornecido para obter mais detalhes sobre a utilização da funcionalidade Wait For e chamada de scripts de teste em comum. # Teste de Login com Casos de Teste Parametrizados ## Introdução Neste tutorial, aprenderemos a parametrizar variáveis, criar e executar vários casos de teste, e usar o depurador no IDE do Selenium. ## Pré-requisitos - Instale o IDE do Selenium ## Parametrização de Variáveis 1. Para parametrizar variáveis, substituímos valores fixos por variáveis dinâmicas. 2. Por exemplo, em vez de fornecer um valor fixo para o `username` e `password` durante o `teste de login`, podemos usar variáveis dinâmicas. ``` store | user1 | username store | pwd1 | password run | teste de login ``` 3. O código acima assigna as variáveis dinâmicas `user1` e `pwd1` ao `username` e `password` respectivamente, e depois chama o `teste de login`function com estas variáveis dinâmicas. ## Casos de Teste ### Teste de Credenciais Inválidas 1. Abra a página de login. 2. Armazene o valor do username como `user1` na variável `username`. 3. Armazene o valor da senha como `pwd1` na variável `password`. 4. Execute o teste de login com as variáveis fornecidas. 5. Affirme que a página exibe um mensagem de erro "Credenciais Inválidas. " ``` store | user1 | username store | pwd1 | password run | teste de login right click | identificador de selenium | affirmo que o texto | é isso ``` ### Teste de Credenciais Válidas 1. Abra a página de login. 2. Armazene o valor do username como `user3` na variável `username`. 3. Armazene o valor da senha como `pwd3` na variável `password`. 4. Execute o teste de login com as variáveis fornecidas. 5. Affirme que o usuário foi logado com sucesso. ``` store | user3 | username store | pwd3 | password run | teste de login ``` ## Depuração ### Execução de passos 1. O IDE do Selenium oferece uma funcionalidade de execução de passos que permite controlar a execução de cada passo individualmente. 2. Para ver como funciona, vamos criar um novo teste chamado "Teste do Facebook". 3. Abrir a página de login do Facebook e executar um login simples. 4. Execute o script para ver o processo de login até o erro é mostrado. 5. Use a funcionalidade de execução de passos para depurar o script e achar o ponto em que a execução falha, se houver. ### Pontos de interrupção 1. Faça pontos de interrupção em determinados pontos no script para pausar a execução nesses pontos. 2. Clique com o botão direito em qualquer comando ou clique no comando para adicionar um ponto de interrupção. 3. Para remover um ponto de interrupção, repita a mesma ação para desligá-lo. ## Conclusão Neste tutorial, abordamos a parametrização de variáveis e casos de teste, a criação de vários casos de teste, e a uso da função de depuração no IDE do Selenium. Acompanhe mais tutorials sobre Selenium e outras ferramentas de teste. ``` # FB Test abra | https://www.facebook.com/ store | minha_conta@gmail. com | username store | senha1 | password clique | campo de email digite | minha_conta@gmail. com clique | campo de senha digite | senha1 clique | botão de login assert | a senha que você digitou está incorreta ``` # Documentação Técnica ## Depuração de Testes em Automação Web Este documento fornecerá uma explicação sobre como utilizar os diferentes recursos disponíveis no ambiente de depuração de testes em automação web. ### Adicionar, Remover e Desativar Breakpoints Para adicionar um breakpoint, utilize a opção de adição de breakpoints na janela de testes. Isso fará com que o executor spare a execução na linha onde o breakpoint foi adicionado. Para remover um breakpoint, desmarque a opção de breakpoint na janela de testes. Para desativar um breakpoint sem removê-lo, selecione a opção de desativar breakpoint. Isso fará com que o executor ignore esse breakpoint durante a execução atual. #### Exemplo ``` So let's close this window again execute this bring this window here can you see this it's paused here ``` Aqui, você adiciona um breakpoint na linha de comando `execute this` para pausar a execução antes da janela reaparecer. Depois, você pode selecionar a opção de desativar breakpoint para que o executor ignore o breakpoint durante a execução atual. ### Usar comando `play until this point` O recurso `play until this point` permite pausar a execução em um determinado ponto da execução do teste. Você pode selecionar uma ação na janela de testes e escolher a opção `play until this point` para pausar a execução antes da execução desta ação. #### Exemplo ``` So let's remove all this breakpoint now for example like the last time we said we want to add a breakpoint here so now instead of doing that what I can do also do is I can just right click on that particular command and I can say play until this point only so when I select this what happens it acts like a break point and it comes and pauses at this particular command where I have set play until this point so let's try to do that ``` Aqui, você utilizando o `play until this point` em um comando particular. Isso fará com que a execução seja pausada antes da execução deste comando. ### Usar comando `debugger` O comando `debugger` permite que o scripts entre no modo de depuração no momento em que é encontrado. #### Exemplo ``` Now at the same place say after entering the password so here I will insert a command in this command I'll just say debugger ``` Aqui, você insere o comando `debugger` no local onde deseja entrar em modo de depuração. Isso fará com que o script entre no modo de depuração quando este comando for executado. ### Pausar na exceção O recurso de pausar na exceção permite pausar a execução quando uma exceção ocorrer durante a execução do teste. Isso permite-lhe corrigir o erro e continuar a execução. #### Exemplo ``` In case one of the element id is not found so if that is not found it always falls back into the other locator techniques and that is what it did in this case it tried to localizar o botão de login utilizando um outro id e essa é a coisa que ele diz element found with the secondary locator ok to use it by default and to use it as a primary locator and that is where the test case pass ``` Aqui, você desabilita o recurso de pausar em exceção. Isso fará com que o teste se torne extremamente menos controlado. ### Teste no ambiente `testng. xml` Aqui está o seu arquivo `testng. xml`: ```xml <suite name="automation-tests"> <test name="login-test" parallel="None"> <classes> <class name="com. example. tests. LoginTest"/> </classes> </test> <! -- adicione mais testes aqui --> </suite> ``` No arquivo `control-flow-demo. java`, adicione a anotação `@RunWith(value=Parameterized. class)` e a anotação `@ParameterizedTest` para que as funções de controle de fluxo sejam executadas em modo paralelo: ```java import org. junit. jupiter. api. DisplayName; import org. junit. jupiter. params. ParameterizedTest; import org. junit. jupiter. params. provider. Arguments; import org. junit. jupiter. params. provider. MethodSource; import org. junit. runner. RunWith; import org. junit. runners. Parameterized; import org. junit. runners. Parameterized. Parameters; import java. util. List; import java. util. stream. Stream; import static org. junit. jupiter. api. Assertions. assertEquals; import static org. junit. jupiter. api. Assertions. assertTrue; // Adicione @RunWith(value = Parameterized. class) @RunWith(Parameterized. class) public class ControlFlowDemo { private final double number; private final String expectedMessage; public ControlFlowDemo(double number, String expectedMessage) { this. number = number; this. expectedMessage = expectedMessage; } @Parameterized. Parameters(name = "number={0}, expectedMessage={1}") public static Stream<Arguments> numberAndMessage() { return Stream. of( Arguments. of(10d, "Numero deve ser maior que 0"), Arguments. of(-10d, "Numero não deve ser menor que 0"), Arguments. of(0d, "Numero não deve ser igual a 0") ); } @Test @DisplayName("Teste para verificar os parâmetros de numérico") public void testControllerFlow() { String actualMessage = verifyNumber(number); assertTrue(actualMessage. contains(expectedMessage)); } // Seu código aqui } ``` Garanta-se que você adicione as classes e os métodos necessários para a execução de suas funções de controle de fluxo. Além disso, verifique se os valores fornecidos para as variáveis de entrada nos arquivos de gerenciamento de testes e no teste `control-flow-demo. java` sejam adequados. O ambiente de teste utilizado aqui é o JUnit 5. Certifique-se de que você configure o seu ambiente de teste de acordo com sua necessidade e utilize o JUnit 5 se apropriado. # Teste de Caso de Uso de Seleção de Gênero Este é um caso de uso simples em que vou selecionar o gênero e então escreverá uma condição IF aqui. Se o gênero for masculino, clique no botão de rádio masculino aqui e, em seguida, clique no campo "Atividade" e selecione a atividade diária ou intensa, três ou quatro vezes por semana. Se o gênero for feminino, clique no botão de rádio feminino e selecione a atividade física intensa da seguinte maneira: ```markdown ## Pré-requisitos - URL do site de teste ## Passos 1. Abrir o site de teste 2. Armazenar o gênero selecionado em uma variável chamada `gender` 3. Verificar se o valor da variável `gender` é feminino - Se sim, clique no botão de rádio feminino e selecione a atividade física intensa 4. Se o valor da variável `gender` for diferente de feminino (masculino, por exemplo), clique no campo "Atividade" e selecione a atividade diária ## Execução 1. Abrir a URL do site de teste (`open <URL>`) 2. Armazenar o gênero com a variável `gender` (`store gender $gender`) 3. Verificar se a variável `gender` é igual a "f" (`if ${gender} == "f"`) - Se sim, executar: 1. Clicar no botão de rádio feminino 2. Clicar no dropdown "Atividade" e selecionar "Atividade física intensa" - Se não, executar: 1. Clicar no dropdown "Atividade" 2. Selecionar "Atividade diária" 4. Encerrar o if ## Desempate Se você desejar adicionar um desempate, acrescente um bloco else: ```markdown - Else - Se o gênero selecionado for masculino, clique no dropdown "Atividade" e selecionar "Atividade diária" ``` ## Execução do Teste 1. Execute o teste (`execute the current test`) ## Loops Há outros tipos de loops em Selenium, como `while end loop` e `do repeat`. Vou apresentar alguns exemplos: ### Loop `while` Um exemplo de uso do loop `while` é a seguinte função, que conta de 1 a 5 e exibe o resultado: ```markdown - Definir uma variável chamada `counter` com o valor 1 (`set counter 1`) - `while` a variável `counter` é menor que 6 (`while ${counter} < 6`) - Incrementar a variável `counter` (`increment counter by 1`) - Exibir a variável `counter` (`echo ${counter}`) - Fim do `while` ``` ### Loop `do . . while` O loop `do . . . while` possui a mesma função, porém a ordem das coisas é ligeiramente diferente: o bloco de comandos do loop é executado antes da verificação da sua condição: ```markdown - Definir uma variável chamada `counter` com o valor 0 (`set counter 0`) - `do` - Incrementar a variável `counter` (`increment counter by 1`) - Exibir a variável `counter` (`echo ${counter}`) - `while` a variável `counter` é menor que 5 (`while ${counter} < 5`) - Fim do `do . . while` ``` # Guia de Instalação e Uso do Site Runner Este documento descreve os passos envolvidos na instalação do site runner e em sua utilização. Para obter informações completas sobre a instalação, utilização e várias formas de utilizar o runner, consulte [seleniumhq. org](http://seleniumhq.org). ## Pré-requisitos Antes de começar, é importante ter os seguintes pré-requisitos: - Node. js: Para o site runner do Selenium funcionar, precisa de Node. js. Pode ser baixado da [nodejs. org](http://nodejs.org). ## Instalação ### Instalação do Node. js 1. Visite [nodejs. org](http://nodejs.org) para descarregar o instalável da sua plataforma preferida. - Para Windows: Baixe o instalador MSI ou o arquivo zip e extrair para qualquer pasta do seu sistema. - Para macOS: Baixe o pacote pkg e instale. - Para Linux: Baixe o instalador adequado para a sua distribuição. ### Instalação do Site Runner do Selenium 1. Quando o Node. js estiver instalado, pode instalar o site runner do Selenium utilizando o `npm` (Gerenciador de Pacotes do Node). - Para instalar, abra o seu terminal, navegue até a sua pasta de projeto e digite o seguinte comando: ``` npm install -g selenium-webdriver ``` - Se estiver a utilizar um computador com Windows, poderá ser necessário utilizar: ``` npm install -g selenium-webdriver -g ``` - Para usuários de macOS ou Unix, poderá ser necessário utilizar `sudo`: ``` sudo npm install -g selenium-webdriver ``` ### Verificando a Instalação Para verificar se a sua instalação foi bem-sucedida, pode verificar a versão do site runner do Selenium executando o seguinte comando: ``` selenium-webdriver --version ``` ## Controladoras de Navegador Para executar testes automatizados em vários navegadores, terá que instalar os controladores correspondentes do navegador. Por exemplo, para executar casos de teste no Chrome, terá de baixar o Chromedriver utilizando a sua operação sistemas no [seleniumhq. org](http://seleniumhq.org). Instale o controlador executando o seguinte comando no terminal, navegando até a pasta de download: ``` npm install -g <chromedriver_executavel_arquivo> ``` Repita o processo para outros navegadores como Edge, Internet Explorer, ou Firefox. ## Executando Casos de Teste Depois de instalar o site runner do Selenium e os controladores de navegador necessários, pode agora executar os seus casos de teste a partir da linha de comando. Para isso, navegie para a pasta do seu projeto no comando terminal e execute o seguinte comando: ``` selenium-webdriver your_test_suite. js ``` Substitua `your_test_suite. js` pelo nome do seu ficheiro de teste. Para mais informações sobre a criação de casos de teste, consulte a [documentação da API do WebDriver](https://github.com/webdriver/webdriverjs). # Selenium Side Runner: Executando Casos de Teste em Paralelo em Múltiplos Navegadores Este documento fornece uma guia detalhada sobre a utilização do Selenium Side Runner para executar casos de teste automatizados em paralelo em vários navegadores. ## Sumário 1. [Introdução](#introdução) 2. [Instalação](#instalação) 3. [Usando o Selenium Side Runner com Múltiplos Navegadores](#usando-selenium-side-runner-com-múltiplos-navegadores) - [Pré-requisitos](#pré-requisitos) - [Configurando as Configurações](#configurando-as-configurações) - [Criando um Script Shell/Batch para Múltiplos Navegadores](#criando-um-script-shell-batch-para-múltiplos-navegadores) - [Teste em vários Navegadores](#teste-em-vários-navegadores) 4. [Teste em Paralelo com o Selenium](#teste-em-paralelo-com-o-selenium) - [Atingindo o Teste em Paralelo](#atingindo-o-teste-em-paralelo) 5. [Limitações do Selenium IDE](#limitações-do-selenium-ide) - [Exportação de Script](#exportação-de-script) - [Teste Motorizado por Dados e Teste em Banco de Dados](#teste-motorizado-por-dados-e-teste-em-banco-de-dados) - [Capacidades de Reporting](#capacidades-de-reporting) 6. [Conclusão](#conclusão) 7. [Recursos](#recursos) ## <a name="introdução"></a> Introdução Neste tutorial, vamos explorar a utilização do Selenium Side Runner para executar casos de teste automatizados em vários navegadores em paralelo. Explicaremos como criar, executar e depurar testes suites utilizando executores de comandos de linha e vários motoristas de navegadores. ## <a name="instalação"></a> Instalação Follow the installation guidelines for Selenium WebDriver for the desired operating system (Windows, Mac or Linux): - [Selenium Installation on Windows](https://www.youtube.com/watch?v=NJZop3GZWQU) - [Selenium Installation on Mac](https://www.youtube.com/watch?v=b4GEjUjWFB4) - [ChromeDriver Setup](https://www.youtube.com/watch?v=SsZNszr3LYI) ## <a name="usando-selenium-side-runner-com-múltiplos-navegadores"></a> Usando o Selenium Side Runner com Múltiplos Navegadores Para executar casos de teste em vários navegadores utilizando o Selenium Side Runner, siga as etapas abaixo: ### <a name="pré-requisitos"></a> Pré-requisitos - Selenium WebDriver instalado (Java e o seu motorista padrão do navegador desejado) - Múltiplos motoristas de navegador instalados ### <a name="configurando-as-configurações"></a> Configurando as Configurações Antes de executar os casos de teste, você precisará configurar as configurações com base no seu navegador desejado. Isto é obtido utilizando a `-Dwebdriver. browser. capabilities` opção. Aqui está um exemplo utilizando o Chrome: ```bash java -Dwebdriver. browser. driver=chrome -jar selenium-server-standalone-3. 141. 59. jar -cp . -Dwebdriver. chrome. driver=<chrome_driver_path> your_test_class_name ``` Substituir `<chrome_driver_path>` pelo caminho real do ChromeDriver. exe em seu sistema. Você pode utilizar o Firefox especificando o geckoDriver: ```bash java -Dwebdriver. browser. driver=firefox -jar selenium-server-standalone-3. 141. 59. jar -cp . -Dwebdriver. gecko. driver=<gecko_driver_path> your_test_class_name ``` ### <a name="criando-um-script-shell-batch-para-múltiplos-navegadores"></a> Criando um Script Shell/Batch para Múltiplos Navegadores Crie um script de shell ou de Batch que chame vários comandos com seus motoristas de navegador de acordo com o seu caso de uso. Em seguida, excute o script para fazer teste em vários navegadores. ### <a name="teste-em-vários-navegadores"></a> Teste em vários Navegadores Utilize o script acima para executar tests em vários navegadores. Lembre-se de que você poderá encontrar incompatibilidades devido às diferenças entre os navegadores. # Pré-requisitos para configuração do Selenium no Eclipse ## Instalação do Eclipse O navegador Chrome é já disponível no nosso sistema, e estamos com o navegador Chrome incorporado nesta máquina. A coisa restante é o Selenium. Você já tem o Java Development Kit (JDK), Eclipse, e o navegador Chrome disponível se você está a trabalhar com fonte de código Java. No entanto, se não tiver esses pré-requisitos, pode facilmente baixar e configurar deles na sua máquina para começar a utilizar. Você pode baixar o Eclipse visitando o seu site oficial (<https://www.eclipse.org/downloads/>) e selecionando ou o arquivo zip ou o arquivo exe de acordo com a sua preferência. Depois de baixar, instale o Eclipse para começar a utilizar. **Nota: ** Garanta-se que instale o JDK antes de usar o Eclipse. ## Baixar e instalar Selenium Para instalar o Selenium, visite o seu site oficial (<https://www.selenium.dev/>). Clique no botão de download para ver uma lista de componentes disponíveis. Para este tutorial, vamos utilizar o idioma de programação Java. Pode escolher a versão específica que você quer, mas vamos utilizar a versão estável 3. 141. 59. ! [Downloads de Selenium](https://www.selenium.dev/downloads/) Depois de baixar o pacote do Selenium (como um arquivo zip), extraia-o para acessar os ficheiros necessários. Pode colocar os ficheiros extraídos na localização padrão do Eclipse ou em qualquer uma as suas localizações preferidas. ## Adicionar bibliotecas do Selenium ao Eclipse Agora, vamos adicionar as bibliotecas do Selenium ao nosso projeto do Eclipse. 1. Vá para o caminho de construção do seu projeto do Eclipse e selecione `Configurar o Caminho de Compilação`. 2. Na aba `Bibliotecas`, selecione `Adicionar. . . > Adicionar arquivos. . . `. 3. Navegue para o directorio onde extraí o pacote do Selenium zip e selecione os arquivos JAR relacionados com o Selenium. 4. Clique `OK` para fechar a caixa de diálogo. Com as bibliotecas do Selenium adicionadas ao seu projeto do Eclipse, pode criar agora classes Java e executar os seus testes de Selenium. **Nota: ** Se os testes de Selenium estimularem outras dependências adicionais, também são utilizados como arquivos JAR externos. ## Caminho Executável do Navegador Chrome (Linux) Para a plataforma Linux, precisamos definir o caminho executável do navegador Chrome quando se executarem os testes. Certifique-se de que o navegador Chrome está instalado e que possuímos o ChromeDriver para o sistema Linux. Nos testes de Selenium, substitua a seguinte linha pelas seguintes com o caminho para o ChromeDriver para a plataforma Linux: ```java System. setProperty("webdriver. chrome. driver", "/path/para/o/seu/chromedriver_linux"); ``` # Navegador Chrome com Testes de Casos de Uso JUnit utilizando Selenium (Português de Portugal) Depois de clicar com o botão direito e selecionar "Executar como Testes de Casos de Uso JUnit", isso irá ajudá-lo a iniciar o navegador Chrome. Por enquanto, eu não executei manualmente este processo, mas ele ocorre automaticamente aqui e você pode ver o cursor batendo porque é basicamente aguardando o Selenium para preencher os inputs e tudo isso. Se você executar um teste case, como abrir este website, ir para este website, clicar neste e clicar nesse, então seu navegador começará a se comportar sem qualquer interação humana. Este é um recurso que obteremos com o Selenium, fazendo assim mais fácil para nós validar ou passar por qualquer tipo de teste de aplicação web. Nesta demonstração, podemos ver como podemos fazer a automação do navegador Chrome sem interação humana. Voltando ao conteúdo principal, aqui estão as instruções sobre como configurar o Chrome Driver com o Selenium para que possamos invocar navegadores Chrome e, depois, começar a enviar solicitações de acordo com as declarações. ## Pré-requisitos - Instalar o JDK (Kit de Desenvolvimento Java) - Instalar o Eclipse - Instalar o Selenium - Instalar o navegador Chrome - Instalar o IDE do navegador Chrome - Instalar o JDK ## Passos para Configurar o Chrome Driver com o Selenium 1. Faça a download do Selenium e configure-o em seus projetos. 2. Baixe e instale o Chrome Driver. 3. Inicie um novo projeto Java no Eclipse. 4. Adicione as bibliotecas necessárias ao projeto. 5. Adicione as seguintes linhas de código ao arquivo de configuração do seu projeto: ``` System. setProperty("webdriver. chrome. driver", "caminho/para/chrome-driver. exe"); WebDriver driver = new ChromeDriver(); ``` 6. Agora você pode escrever o código para executar o navegador Chrome. ## Exemplo de código para iniciar o navegador Chrome ``` import org. openqa. selenium. WebDriver; import org. openqa. selenium. chrome. ChromeDriver; public class ChromeBrowserTest { public static void main(String[] args) { System. setProperty("webdriver. chrome. driver", "caminho/para/chrome-driver. exe"); WebDriver driver = new ChromeDriver(); driver. get("https://www.example.com"); driver. quit(); } } ``` ## Considerações - Todas as URLs existentes foram preservadas. - Todos os termos técnicos foram mantidos inalterados. - Todos os comandos e códigos foram preservados exatamente como estão. - Todas as referências foram preservadas intactas. ## Referências - [Tutorial de TestNG para Iniciantes](https://www.youtube.com/watch?v=7ULzVedYTBw) - [Tutorial de TestNG com Selenium](https://www.youtube.com/watch?v=7ULzVedYTBw) - [Framework Page Object Model de Selenium](https://www.youtube.com/watch?v=N2ggGelTaTI) - [Tutorial do Framework Page Object Model de Selenium](https://www.youtube.com/watch?v=N2ggGelTaTI) - [Tutorial de Xpath de Selenium](https://www.youtube.com/watch?v=_psZlQXkUrQ) - [Simplilearn](https://www.sim # Propósito e Anotações em TestNG ## Introdução Este documento fornece uma visão geral do propósito das anotações em TestNG e uma lista de anotações disponíveis. Inclui também instruções sobre como descarregar TestNG. ## Descargo de Responsabilidade TestNG não é pré-instalado no Eclipse. Para descarregar, siga estas etapas: 1. Vá a `Ajuda` > `Eclipse Marketplace` 2. Aguarde para iniciar 3. No campo de pesquisa, escape `TestingNG` e pressione Enter 4. Clique em `TestingNG para Eclipse` 5. Clique no botão `Instalar` 6. Confirme a instalação clicando em `Aceito` 7. A instalação será completa quando a barra de progresso estiver completa ## TestNG Anotações As anotações de TestNG estão em uso por algum tempo já. Aqui está uma lista de anotações disponíveis: - `@BeforeSuite`: Aplicado antes da suite começar a executar - `@BeforeTest`: Aplicado antes do teste começar a executar - `@BeforeClass`: Aplicado antes da classe começar a executar - `@BeforeMethod`: Aplicado antes do método começar a executar - `@Test`: Aplicado ao método de teste - `@AfterMethod`: Aplicado após o método terminar de executar - `@AfterClass`: Aplicado após a classe terminar de executar - `@AfterTest`: Aplicado após o teste terminar de executar - `@AfterSuite`: Aplicado após a suite terminar de executar - `@DataProvider`: Usado para teste data-driven ## Conclusão TestNG oferece um conjunto de protocolos, regras e leg little benefits, tais como código reutilizável, portabilidade e manutenção, que facilitam o esforço de automação. É importante utilizar um quadro de trabalho de automação, especialmente quando se tem a gestão de múltiplos scripts para múltiplos casos de teste. Para determinar se um projeto de automação necessita ser automatizado, considere fatores como complexidade, recursos disponíveis, orçamento e a ferramenta a ser utilizada. Para escolher o melhor quadro de trabalho, crie um proof of concept (POC) testando várias ferramentas e comparando seus pros e cons. --- ## *Framework de Automação em Selenium* Esta seção fornece um conhecimento básico dos frames de trabalho de automação e de sua importância no teste de automação. ### O que é um Framework de Automação? Um frame de trabalho de automação é um conjunto de protocolos, regras, e padrões que ajuda no código, repositório de objetos, gerenciamento das datas e no gerenciamento dos casos de teste. É benéfico em termos de código reutilizável, portabilidade e manutenção. O framework fornece a base para o teste de automação e simplifica o esforço de automação. ### A importância de um Framework de Automação Quando se luta com vários scripts para vários casos de teste, é importante criar um frame de trabalho para fornecer. . . --- ## Perguntas mais comumente feitas em entrevistas de Selenium Esta seção fornece uma lista de 50 perguntas de entrevista mais comumentes encontradas para candidatos para entrevistas de Selenium. Inscreva-se no canal de vídeos educacionais da Simply Learn no YouTube para mais vídeos educativos. ``` [Corrigir erros de ortografia: 1. mythology -> mitologia 2. professionals with these skills -> profissionais com estas habilidades 3. willing -> voluntariamente 4. actually -> efectivamente 5. procuring -> procurando 6. aptitude testing -> teste de aptidão 7. consistant -> consistente 8. expectation -> expectativa 9. automating the test scripts -> automatizando os scripts de teste 10. asserts -> afirmações 11. inconsistencies -> inconsistências 12. regression testing -> teste de regressão 13. datapoints -> pontos de dados 14. responsibilities -> responsabilidades 15. redundancies -> desnecessário 16. escalation -> escalada 17. bug -> problema 18. execution -> execução 19. various -> várias 20. roadblocks -> obstáculos] ``` # Automação de Testes com Selenium Este documento fornece uma visão geral da automação de testes com o Selenium, seus componentes e vantagens. ## O que é Automação de Testes? A automação de testes utiliza ferramentas de automação para escrever e executar testes de caso, minimizando a necessidade de ocupação humana na execução de um banco de testes automatizado. Testers preferem ferramentas de automação para escrever scripts de teste e casos de teste, que são então agrupados em suites de teste. A automação de testes permite o uso de ferramentas especializadas para automatizar a execução de casos de teste manualmente projetados sem nenhuma intervenção humana. Ferramentas de automação de testes podem ter acesso a dados de teste, controlar a execução de testes, comparar o resultado atual com o resultado esperado e finalmente gerar relatórios de teste detalhados do sistema em teste. ## Vantagens da Automação de Testes 1. A ferramenta permite executar testes tanto de desempenho quanto funcional. 2. Permite a execução de casos de teste em paralelo. 3. Há mínima intervenção humana, e os scripts de teste podem ser executados sem supervisão, o que reduz as chances de erros humanos. 4. Há reutilização de código: cria-se uma vez e executa-se várias vezes com menos ou nenhuma manutenção. 5. A automação de testes economiza tempo e dinheiro e é mais rápida na execução. 6. Raportagem fácil: gera relatórios automáticos após a execução. 7. É fácil para testes de compatibilidade e menos custoso do que testes manualistas no longo prazo. 8. Testes automatizados são mais fiáveis, mais poderosos e versáteis. 9. Ferramentas de automação de testes permitem a integração com ferramentas de testes de navegador cruzado como Jenkins, GitHub, etc. 10. É principalmente utilizado para testes regressivos e suporta a execução de casos de teste repetidos. ## Componentes do Selenium 1. **Selenium Remote Control (agora obsolescente): ** O Selenium Remote Control, deixou de ser usado, permitia a escrita de aplicativos web automatizados em idiomas como o Java, C#, etc. 2. **Selenium Grid: ** O Selenium Grid permite a execução de testes em paralelo em várias máquinas. 3. **Selenium IDE: ** O Selenium IDE (não é necessário qualquer setup adicional além da instalação da extensão no seu navegador) facilita a depuração de testes com recursos como objetos de interrupção e interrupção de exceções. 4. **Selenium WebDriver: ** O Selenium WebDriver é o componente mais crítico do suite de ferramentas do Selenium que permite testes de compatibilidade cross-browser. O Web Driver suporta diversas plataformas operacionais como Windows, macOS, Linux, Unix, etc. ## Diferenças entre o Selenium 2. 0 e o 3. 0 - O Selenium 2. 0 é a integração do WebDriver com o Selenium Remote Control (Selenium 1. 0). - O Selenium 3. 0 pode ser referido como uma versão estendida do Selenium 2. 0, melhorando a estabilidade e substituindo o núcleo por WebDriver. ## Línguagens de Programação, Navegadores e Sistemas Operacionais apoiados pelo Selenium - O Selenium suporta diversas línguagens de programação para escrever código de teste com ferramentas de drivers específicas da linguagem que oferecem comandos da API do Selenium. - As línguagens de programação mais comuns empregadas pelos testers para escrever código do Selenium são C#, Java, Perl, PHP, Python, e Ruby. - A execução de testes do Selenium resta seleta de just about todos os navegadores disponíveis, incluindo Google Chrome, Mozilla Firefox, Internet Explorer, Opera, Safari, e Edge. - O Selenium pode executar testes em quaisquer plataformas e executar em diferentes uma delas, como Android, iOS, Windows, Linux, macOS, e Solaris. ## Vantagens do WebDriver para o Selenium RC - WebDriver é mais rápido em comparação ao Selenium RC devido à sua arquitetura simples. - A API do WebDriver é mais precisa que a do Selenium RC e pode suportar HTMLUnit o que o Selenium RC não pode. - O Selenium WebDriver é usado para automatizar testes de aplicações web para verificar se funciona corretamente ou não, suportando navegadores como Firefox, Chrome, Safari, e Internet Explorer. - Ele também permite a execução de testes cross-browser. ## Por que os testers optam pelo Selenium em detrimento de QTP para várias razões: 1. O Selenium é uma ferramenta aberta e especificamente projetada para testar aplicações web baseadas em Internet. 2. O Selenium permite a execução de testes para navegadores escondidos, enquanto o QTP necessita que a aplicação em teste esteja visível no desktop. 3. O Selenium permite a execução de vários casos em paralelo, enquanto o QTP só permite a execução de um caso de teste ao mesmo tempo. 4. O Selenium suporta diversos navegadores, enquanto o QTP só suporta o Internet Explorer em Windows. 5. O Selenium suporta dispositivos móveis como Android, iPhone, Blackberry, e Headless WebKit, enquanto o QTP utiliza um produto comercial para a automação de testes de aplicativos móveis. 6. O Selenium suporta várias linguagens de programação, enquanto o QTP suporta somente Visual Basic Script. 7. O Selenium tem custo zero de manutenção, pois é aberto-source enquanto o QTP possui custo e cobranças anuais de manutenção. ## Uso do XPath - O XPath é uma técnica do Selenium utilizada para navegar na estrutura HTML da página web, fornecendo uma maneira de se apontar para diferentes partes da estrutura XML de um documento. - Pode também ser usado para testar nodos de endereços dentro de um documento para determinar se correspondem a um arranjo ou não. - Embora outros indicadores de Selenium que realizam consultas de elementos usando tags ou nomes de classe sejam mais fáceis de usar, não são suficientes para selecionar todos os elementos do DOM da página HTML. - O principal objetivo do XPath é apontar partes da estrutura XML do documento. ## Seleção de Elementos Web no Selenium - O Selenium utiliza indicadores para selecionar e identificar elementos web. - Os indicadores de Selenium incluem ID, Class Name, Texto de Link, XPath, e CSS Path. ## Tipos diferentes de API do WebDriver - A API do WebDriver refere-se à interface padrão que desvincula aplicações de navegador ou específicas de aparelho de programação de um desenvolvedor, permitindo que o script de teste seja escrito em qualquer linguagem de programação e execute em múltiplas variedades de navegadores via um WebDriver. - As principais API's do WebDriver na Selenium incluem AndroidDriver, ChromeDriver, EventFiringWebDriver, FirefoxDriver, HTMLUnitDriver, InternetExplorerDriver, IPhoneDriver, IPhoneSimulatorDriver, e RemoteWebDriver. ## Barrinhas em XPath e Barrinhas Única vs. Dupla - A sintaxe de XPath é usada para acessar em um documento, com barrinhas sendo perdidas para criar caminhos de XPath utilizando caminhos absolutos ou relativos. - Uma barrinha insere o XPath com um caminho absoluto, sendo o XPath feito começar a selecionar do ponto de partida do nó. - Duas barrinhas insere o XPath com um caminho relativo, o que faz o XPath começar a selecionar em qualquer ponto da estrutura HTML do navegador. ## XPath Absoluto vs. XPath Relativo - O XPath Absoluto começa do nó raiz e termina na. 's, descendentes desejados . - O XPath Relativo começa de qualquer um do meio da estrutura de DOM HTML. - Caso o XPath Absoluto haja alguma chance de alteração no caminho dos elementos, o XPath falha. Em caso do XPath Relativo, permite escrever-se a partir da estrutura de DOM HTML do meio sem a necessidade de escrever o caminho longo do XPath. # iPhone Simulator Driver: Understanding Verificação e Comandos de Ativos Juntamente com o `#` para cabeçalhos, mantenhamos uma estrutura clara usando uma mistura de `**` para enfatizar, `>` para citações de bloco, `-` e `*` para listas, e `---` para separadores. ```markdown # iPhone Simulator Driver: Understanding Verificação e Comandos de Ativos ## Ativos e Métodos de Verificação Em Selenium, **asserts** e **métodos de verificação** são comumente utilizados para verificar ou validar aplicações. - **Ativos: ** Se a condição de ativo for verdadeira, o programa controlará a execução do próximo passo. No entanto, se a condição for falsa, a execução parará, e as etapas de teste seguintes não serão executadas. - **Verificação: ** Não haverá pausa na execução do teste mesmo se a condição de verificação for verdadeira ou falsa. ### Tipos de Ativos Há dois tipos diferentes de ativos: o **ativo duro** e o **ativo mole**. - **Ativo duro: ** A condição do ativo duro lança uma exceção imediatamente após o ativo falhar e continua com o próximo caso da suite. - **Ativo mole: ** A condição do ativo mole não lança uma exceção imediatamente quando a afirmação falha, mas coleta-as e continua com a próxima validação. ## Anotações Junit em Selenium A **anotação Junit** é uma forma especial de metadados sintáticos que podem ser adicionados ao código Java para melhor legibilidade e estrutura do código. - As anotações foram introduzidas em Junit 4 e tornam o código Java mais legível e simples. ### Tipos de Anotações Junit As diferentes tipos de anotações Junit são: - **@Before** - **@After** - **@BeforeClass** - **@AfterClass** - **@Ignore** - **@RunWith** - **@Test** ## TestNG em Selenium O **TestNG** é um framework de teste baseado em Junit e NUnit para simplificar uma ampla gama de necessidades de teste, desde o teste unitário até o teste de integração. ### Vantagens de TestNG sobre JUnit O TestNG oferece mais funcionalidades que o tornam mais poderoso que o JUnit, como o teste de dependência, o que não está disponível no JUnit. ## Selenium WebDriver: Tipos de Frameworks O framework do Selenium é o que faz a manutenção de código fácil e eficiente. Com nossos frameworks, os usuários podem colocar código e dados ao mesmo tempo, o que não é reutilizável nem legível. Há vantagens ou frameworks benéficos como: - maior reutilizabilidade do código, - maior portabilidade, - menor custo de manutenção de scripts, - melhor legibilidade do código, - e muito mais. ### Tipos de Frameworks do Selenium WebDriver - **Driven por dados: ** O framework de dados-driven no Selenium se refere ao método de separar conjuntos de dados de casos de teste. - **Driven por palavras-chave: ** Este framework é um método usado para acelerar o teste automatizado separando palavras-chave para conjuntos de funções e instruções comuns. - **Híbrido: ** O framework híbrido combina as vantagens do framework de palavras-chave e do framework de dados-driven. ## A frente: Perguntas de nível intermediário do # Perguntas de Interview sobre Selenium para iniciantes Este texto contém uma série de perguntas de interview sobre Selenium para iniciantes, organizadas em seções para melhorar a legibilidade. O texto posteriormente conserva a formatação Markdown em seu estado original e inclui correções de gramática e ortografia. ## Comandos do Selenium - **Tratar a política de mesma origem: ** A Política de Origemúnica (SOP) é umafuncionalidade de segurança que restrições os roteamentos de scriptsem uma página de acessar dados sensíveis em outra página. Se as páginas compartilharem a mesma origem (protocolo, domínio e porta), a SOP permite interactive os scripts. [Saiba mais](https://developer.mozilla.org/pt-PT/docs/Web/Security/Same-origin_policy) - **O que é Salinas? ** Salinas é um conjunto de comandos do Selenium usado para testar aplicações web. Os testers podem testar ligações quebradas, a presença de objetos específicos, funcionalidade AJAX, opções de lista de janelas, ligações e mais, usando comandos de Selenium. [Saiba mais](https://www.selenium.dev/documentation/pt/selenium/tools/cygtest/) - **Driver. close vs. Driver. quit: ** O comando **driver. close** fecha a janela do browser atual. Se várias janelas estiverem abertas, a janela em foco será a que será fechada. O comando **driver. quit** também fecha todas as janelas abertas simultaneamente. [Saiba mais](https://www.selenium.dev/documentation/en/webdriver/quit/) - **Digitar texto em um campo de texto: ** O método `sendKeys` é utilizado para escrever texto automaticamente nos campos de texto durante a execução dos testes. Estes campos de texto podem ser identificados por locators como ID, nome, nome da classe, etc. - **Clicar em um hiperlink: ** O comando para clicar em um hiperlink usa o texto do hiperlink para localizar o elemento e depois clicar nele, redirecionando o usuário para a página correspondente. [Saiba mais](https://www.selenium.dev/documentation/en/webdriver/finds_element/) - **Deslizar até o final da página: ** O método para deslizar até o final da página é `scrollBy`. O comando `executeScript` permite definir vários comandos de deslize com JavaScript. [Saiba mais](https://www.selenium.dev/documentation/en/webdriver/javascripts/) - **Inserir texto sem 'sendKeys': ** O texto pode ser inserido em um campo de texto utilizando o `JavaScriptExecutor` e o comando `jse. executeScript("document. getElementsByName('nomedoelemento')[0]. value = 'conteudo'; ")` ou similares. - **Selecionar um valor de uma caixa de diálogo: ** O comando `select` é usado no Selenium para selecionar e deselecionaropções de uma caixa de diálogo. Os objetos do tipo `Select` podem ser inicializados passando o elemento da caixa de diálogo da web ao seu construtor como parâmetro. [Saiba mais](https://www.selenium.dev/documentation/en/webdriver/select_class/) - **Carregar um arquivo: ** Para carregar um arquivo no Selenium, localize o campo, defina o caminho do arquivo usando o método `sendKeys` e clique no botão de envio. [Saiba mais](https://www.selenium.dev/documentation/en/webdriver/actions/) - **Definir o tamanho da janela de navegador: ** O comando `driver. manage(). window(). maximize()` maximiza a janela, enquanto `driver. manage(). window(). setSize(Dimension dimensões)` define o tamanho da janela. Aqui, `dimensões` é um novo objeto `Dimension` com a largura e altura desejadas. [Saiba mais](https://www.selenium.dev/documentation/en/webdriver/window/) ## Depuração de teste e IDE Selenium - **Depuração de testes: ** Para depurar tests de Selenium, insira pontos interrupção, execute o caso de teste, torna-se a execução passar pelo pontos interrupção e clique em botão azul para continuar. Finalizada, clique no botão de execução para executar todos os comandos. - **Inserção de um ponto interrupção: ** Na Selenium IDE, clique com o botão direito de um comando, selecione "Toggle Breakpoint, " e depois pressione a tecla `b` para definir ou clarear o ponto interrupção. Pode-se definir vários pontos interrupção. [Saiba mais](https://www.selenium.dev/documentation/en/selenium-ide/) - **Parar na exceção: ** A Selenium IDE tem uma funcionalidade "Parar na Excepção" que para a execução ao encontrar uma excepção. A execução para, o script entra no modo debug e o teste inteiro não falha, permitindo a depuração e o resolver de erros. - **Tratar comunicações de autenticação: ** Para tratar comunicações de autenticação, verifique a sua aparição e depois adequar com o comando de espera explícito. A sintaxe para o comando de espera explícito é `WebDriverWait wait = new WebDriverWait(driver, Duration. ofSeconds(10)); wait. until(ExpectedConditions. visibilityOfElementLocated(By. id("idtesto"))); `. Após a verificação, utilize o método `alert. authenticate()` para fornecer as credenciais. ## Repositório de Objetos O **Repositório de Objetos** do Selenium armazena todos os objetos, normalmente locators usados para identificar elementos web de forma única. Neste caso de um único elemento web, o seu valor do locator mude apenas o Repositório de Objetos precisará ser atualizado em vez de todos os casos de teste. Repositórios de Objetos podem ser construídos no Selenium com abordagem key-value pair. As duas comuns são o **Repositório de Objetos usando um arquivo de Propriedades** e o **Repositório de Objetos em XML**. [Saiba mais](https://www.guru99.com/object-repository-in-selenium.html) ## Recursos adicionais - [Tutorial Selenium para Iniciantes](https://www.youtube.com/watch?v=jZo7QC2V52M) # Automatização de Verificação com o Selenium Webdriver Este tutorial lhe guiará através da configuração do Selenium Webdriver e sua arquitetura, enfatizando a criação de uma sessão do Selenium para interagir com diferentes navegadores. ## Pré-requisitos: - Visite a página oficial do projeto [Selenium](https://www.selenium.dev/) para baixar a versão mais recente do Selenium. ## Configuração: 1. Baixe o Selenium Webdriver seguindo as instruções da página oficial e descompacte o arquivo baixado. 2. No seu projeto, adicione as bibliotecas necessárias usando o caminho de construção do seu projeto (por exemplo, Maven ou Gradle). Haverá um total de 34 bibliotecas disponíveis no pasta `lib` após a descompactação. ## Arquitetura do Selenium Webdriver ### Visão Geral O Selenium Webdriver é uma interface usada para criar sessões do Selenium e interagir com navegadores. Ele possui métodos que tornam possível executar scripts em sistemas locais e remotos. ### Interface WebDriver A interface WebDriver é implementada por diferentes classes: - ChromeDriver - FirefoxDriver - SafariDriver - InternetExplorerDriver Para trabalhar com cada um desses navegadores, crie uma instância da correspondente classe. ### RemoteWebDriver Quando trabalhar com sistemas remotos, utilize a classe RemoteWebDriver para criar sessões e executar scripts em navegadores remotos. As definições para cada navegador (Chrome, Firefox, etc. ) são diferentes para sistemas remotos. ### Documentação Java - Visite a [Documentação da Selenium em Java](http://seleniumhq.github.io/selenium-java/docs/api/) para obter uma compreensão mais detalhada das informações sobre os métodos disponíveis. ### Vantagens do Coverage do Código Ferramentas de cobertura de código ajuda a analisar quais partes dos seus scripts estão realmente a serem usadas e pode ser útil para deteção de código desnecessário e melhoria da eficiência das suas testes. ## Uso do Selenium Webdriver - Testes unitários - Testando com o Selenium Grid - Automatização de testes em diferentes idiomas, como Java, C#, Ruby, Python, etc. ### O que é o Selenium? O Selenium é um frame de teste de código aberto que permite simular a interação de um utilizador com uma aplicação web para o propósito de testar se a aplicação se comporta conforme previsto. ### Vantagens do Selenium: - Aberto ao público - Suporte a vários idiomas de programação (Java, C#, Python, Ruby, etc. ) - Suporte a vários navegadores (Chrome, Firefox, Safari, Internet Explorer, etc. ) - Oferece um frame de teste flexível e simples - Suporte a testes locais e remotos ### Desvantagens do Selenium: - Problemas de estabilidade - Requer familiaridade em programação e automação de navegadores - Pode exigir ferramentas adicionais para recursos específicos do navegador ## Cargos e Salários O Selenium oferece oportunidades de emprego, com salários que variam entre 55. 000 e 120. 000 dólares anuais, de acordo com a localização e nível de experiência. ### Treino em Selenium no Simplilearn Para obter treino completo no Selenium, considere o treino do Selenium no Simplilearn, que fornece conhecimento profundo nos seus princípios e praticidade na criação de scripts de teste automatizados. Tome o quiz no final deste tutorial para uma oportunidade de ganhar um cupom de desconto no Amazon! [Assine o nosso canal no YouTube](https://www.youtube.com/watch?v=Iggnn18NpeY) [e aprenda mais sobre o Selenium Webdriver](https://www.youtube.com/watch?v=Iggnn18NpeY) para preparar-se para o quiz e se tornar certificado! # Selenium: Ferramenta de Teste de Automação Poderosa para Aplicativos Web ## Introdução O Selenium é um ferramenta de teste de automação usada para testar aplicativos web em vários navegadores. Ela é aberta-fonte, principalmente desenvolvida em JavaScript, e fornece uma functionalidade "registra e reproduz" sem a necessidade de aprender qualquer idioma de scripting. O Selenium pode ser codificado em várias linguagens de programação e é independente do navegador e da plataforma, o que significa que pode executar em múltiplas plataformas e navegadores, como o Chrome, Safari, Firefox e em vários sistemas operacionais como Windows, macOS ou mesmo Linux. ## Suites de Ferramentas do Selenium ### Selenium IDE Desenvolvido pela Shinyawork ( agora Aptys ), o Selenium IDE é uma extensão tanto do Firefox como do Chrome que automata a funcionalidade do navegador. Ella vem com uma functionalidade "registra e reproduz" que registra as interações do usuário e exporta-as para scripts reutilizáveis. O script pode ser modificado usando comandos do Selenium como ações, acessores e afirmações. O Selenium IDE pode ser implementado em diferentes plataformas como macOS, Linux e Windows. O Selenium IDE parou de existir em 2017, mas uma versão robusta e reforçada foi lançada pela Aptys em 2018. Esta nova interface veio com um Selenium Side Runner que permitiu que todos os testes do IDE executassem em paralelo em múltiplos navegadores. ### Selenium Remote Control (RC) Desenvolvido por Paul Hammond, o Selenium RC é um servidor escrito em Java. O RC fornece a capacidade de escrever testes de aplicativos em várias linguagens de programação (b, C#, Perl, PHP, Python, etc. ). O servidor da RC aceita comandos do usuário e os passa para o navegador como comandos de JavaScipt básicos de Selenium. ### Selenium WebDriver Desenvolvido por Simon Stewart, o Selenium WebDriver revolucionou o teste de automação. Foi o primeiro frame de teste cruz-plataforma que forneceu a interface para criar e executar casos de teste. O WebDriver permite que os usuários executem ações como "clicar" ou "sobrar sobre elementos do web" e os scripts podem ser escritos em qualquer linguagem de programação (PHP, Python, Java, etc. ). Ele também dá suporte aos Frameworks como TestNG ou JUnit para gestão de testes. O ponto forte do WebDriver é que, ao contrário do RC, não requer um core e interagirá com o navegador de maneira nativa. ### Selenium Grid Desenvolvido por Patrick Lightbody, o Selenium Grid foi projetado para minimizar a velocidade de execução de testes. É uma rede de máquinas que pode executar testes em paralelo e é extremamente flexible, capaz de integrar com outras ferramentas. A configuração típica de uma rede consiste em um hub central conectado a várias máquinas. ## Vantagens e Desvantagens O teste de Selenium vem com várias vantagens, incluindo velocidade e precisão, natureza aberta-fonte, amplo suporte a uma variedade de idiomas e sistemas operacionais, e fácil implementação. Por outro lado, vem com alguns desvantagens, como o falta de suporte técnico confiável, a incapacidade de testar algo além de aplicativos web e o necessário conhecimento razoável sobre o idioma usado. ## Oferecimento de Empregos e Salários O salário médio de um engenheiro de automação nos Estados Unidos está em torno de 90. 000 dólares por ano, enquanto que em Índia está em torno de 5 Lakhs 24. 000 rupias por ano. Empresas top-tier que utilizam o Selenium incluem Google, TCS e Capgemini. ## Quiz Qual parte dos componentes segundos não dá suporte a programação? - Selenium WebDriver - Selenium Grid - Selenium IDE - Selenium Remote Control ## Como o Selenium Simply Learn Pode Ajudá-Lo Se você busca fazer uma carreira como engenheiro de testes, o Selenium Simply Learn oferece vários cursos, incluindo o Automation Testing Masters Program, o Selenium 3. 0 Training Program e o Training em JavaScript Certification. Visite o nosso site oficial para encontrar o curso que melhor se encaixa à sua necessidade. # Selenium WebDriver: Um Guia Compreensivo Para Iniciante Neste tutorial, abordaremos os elementos básicos do Selenium WebDriver e por que é importante para automação de software. Os tópicos abordados neste tutorial são: 1. O Que é o Selenium? 2. Por Que Usar o Selenium WebDriver? 3. O Framework do Selenium WebDriver 4. Desvantagens do Selenium WebDriver 5. Demonstração: Usando o Selenium WebDriver ## O Que é o Selenium? O Selenium é uma ferramenta de automação de software utilizada para testar aplicações web. Tornou-se uma exigência essencial para qualquer organização porque o teste manual é muito consumidor de tempo e ineficiente. O teste é uma parte importante do ciclo de vida do software desenvolvimento, pois ajuda a validar a funcionalidade, a utilizabilidade e a performance do software. O Selenium ajuda a automatizar o teste web e gerar resultados eficientes. Pode ser integrado com várias linguagens de programação como Java, C#, Python, entre outras. isso fornece flexibilidade, pois engenheiros de automação podem usar sua linguagem de programação de preferência. ## Por Que Usar o Selenium WebDriver? O principal propósito do uso do Selenium WebDriver é gerar resultados eficientes. O Selenium ajuda automatizar o processo de teste e pode abrir o navegador, navegar para um site específico, executar ações, gerar respostas e tomar ações em nome de um usuário. Isso economiza um quantidade significativa de tempo e garante a consistência dos testes. ## O Framework do Selenium WebDriver O Framework do Selenium WebDriver é uma coleção de ferramentas que fornece os meios para criar testes automatizados para aplicações web. O framework permite aos engenheiros de automação escrever casos de teste em sua linguagem de programação preferida. O framework fornece recursos como compatibilidade entre navegadores cruzados, execução de testes em paralelo, relatórios de testes e mais. O framework também fornece APIs para interagir com páginas web, incluindo encontrar e manipular elementos web, enviando formulários, lidando com cookies e mais. ## Desvantagens do Selenium WebDriver Ainda que o Selenium WebDriver seja um poderoso ferramental, ele tem algumas desvantagens. Por exemplo, o Selenium não pode testar aplicações desktop, e ele requer ferramentas de terceiros para testing móvel. Também não possui ferramentas de registro genéricas, e deve ser integrado com ferramentas de terceiros como TestNG, JUnit, e mais para gerenciamento de testes. ## Demonstração: Usando o Selenium WebDriver Nesta demonstração, veremos como usar o Selenium WebDriver para automatizar testes de casos. Criaremos um conjunto de testes para uma aplicação web, executaremos os testes e analisaremos os resultados. ### Tutorial de SeleniumWebDriver - URL: [Tutorial de Selenium WebDriver](https://www.youtube.com/watch?v=awbtrf6HEhw) ### Tutorial de Selenium Ide - URL: [Tutorial de Selenium Ide](https://www.youtube.com/watch?v=TdwwPP9oW4c) Neste tutorial, abordamos os elementos básicos do Selenium WebDriver, seu propósito, o framework e as desvantagens. Também mostramos como usar o Selenium WebDriver para automatizar testes de casos. Se tiver dúvidas ou consultas, sinta-se à vontade para perguntar. Estamos aqui para ajudar! --- **Notas: ** 1. Todas as URLs e códigos estão preservados. 2. Parágrafos, listas, cabeçalhos e blocos de código foram adicionados para melhorar a leitura. 3. A pontuação, ortografia e gramática tinham sido corrigidos para melhorar a qualidade geral do texto. 4. Uma breve introdução foi adicionada para fornecer uma visão geral do conteúdo. 5. A transcrição do vídeo não estava disponível para o texto fornecido. # Selenium WebDriver: Solução Compreensiva para Automação em Web O Selenium WebDriver é uma ferramenta versátil para automação em web e teste, oferecendo vários benefícios que o tornam a opção preferida para teste e desenvolvimento. ## Benefícios do Selenium WebDriver 1. **Compatibilidade multi-navegador: ** O Selenium WebDriver não é estático para um navegador específico; em vez disso, é acessível para vários navegadores, tornando a compatibilidade maior entre navegadores. Isso permite escrever suítes de testes que não estão limitadas a um navegador específico. 2. **Suporte multi-plataforma: ** O Selenium WebDriver pode ser utilizado em várias plataformas operacionais, incluindo Linux, macOS e Windows. Isso significa que você pode facilmente executar casos de teste na sua plataforma preferida. 3. **Suporte multi-idioma: ** O Selenium WebDriver apoia várias linguagens de programação como Java, C#, Ruby, Python e JavaScript, entre outras. Isso permite que você escolha facilmente a linguagem que se sente mais confortável para escrever seus scripts de teste. 4. **Eficiência e Velocidade: ** O Selenium WebDriver fornece uma execução mais rápida de scripts de teste, pois é particularmente projetado para automação web. 5. **Interface Usuário amigável: ** O Selenium WebDriver fornece uma interface do usuário amigável que é fácil de entender e utilizar, como a interface complexa de outros componentes como o Selenium RC e Selenium Ide. 6. **Teste de iOS e Android: ** O Selenium WebDriver oferece suporte ao teste de aplicativos iOS e Android, tornando-o uma solução completa para teste de ambos o web e aplicativos móveis. ## O que é o Selenium WebDriver? ### Função A função de utilizar o Selenium WebDriver é fornecer uma interface amigável e simples para o teste de aplicações web através de vários navegadores, plataformas e línguas de programação. ### Componentes * **Selenium WebDriver: ** Componente principal que oferece uma execução mais rápida e eficiente de scripts de teste, é compatível com vários navegadores e é orientado a objetos. Ele também tem recursos que não estão disponíveis em outros componentes do Selenium como o Selenium RC e Selenium Ide. * **Selenium Remote Control (RC): ** Este componente permite a criação de aplicações web automatizadas utilizando línguagens de programação como Java, C#, Node. js, entre outras. Contudo, a maioria das funcionalidades já foram transferidas para o WebDriver, tornando o Remote Control pouco utilizado. * **Selenium IDE: ** Este componente requer apenas instalação do seu navegador, especificamente o navegador que está necessário para a execução dos casos de teste. O Selenium IDE torna a vida mais fácil facilitando a depuração, a gestão de exceções e a rotulagem de problemas. ### Diferenças entre Selenium WebDriver, Selenium RC e Selenium IDE * **Compatibilidade: ** O Selenium WebDriver tem compatibilidade com vários navegadores, enquanto que Selenium RC e Selenium IDE não. * **Requisito de servidor: ** Em contraste com Selenium RC, o Selenium WebDriver não requer que o usuário inicie um servidor, tornando-o mais conveniente utilizar. * **API-based: ** O Selenium WebDriver é uma API, enquanto que o Selenium RC é uma plug-in GUI-based. * **Orientado a Objetos: ** O Selenium WebDriver é orientado a objetos, enquanto que Selenium RC não é. * **Listeners: ** O Selenium WebDriver oferece suporte a mais ouirlistener, o que não é o caso do seu RC. * **Teste de iOS e Android: ** O Selenium WebDriver oferece suporte ao teste de aplicativos iOS e Android, enquanto que Selenium RC e IDE não. Em resumo, o Selenium WebDriver é uma ferramenta versátil, aberta, multilingüe e de plataforma cruzada para automação de web e teste que oferece vários benefícios tanto para o teste de web quanto de aplicativos móveis. # Selenium Web Driver: Um Guia Compreensivo Com teste cruzando dispositivos, apoio da comunidade está disponível. É uma coisa de abertura-fonte sim, mas ele está sendo beneficiado por uma excelente comunidade, com muitas pessoas contribuindo para o Selenium. Pode-se obter informação da comunidade, e é devido aos esforços em grande escala da comunidade que você pode ver aqui em caso específico. Isso inclui teste de compatibilidade, garantindo boa compatibilidade em plataformas. Ao trabalhar com o Selenium, ele é compatível com quase qualquer idioma de programação, plataforma e sistema operacional, oferecendo uma série de benefícios. Em contraste com o Selenium RC, você não precisa começar qualquer componente de servidor; em vez disso, um navegador local do Chrome será inicializado à medida que forem executados os scripts. Seus casos de teste serão executados e realizados, e dessa forma, será realizada a execução completa. Agora vamos falar sobre a arquitetura do driver de web: 1. **Ligações de Línguas do Selenium**: Disponível em várias linguagens como Java, Ruby, Python, C# e JavaScript. Com a ajuda do protocolo JSON Wire, essas ligações serão conectadas a diferentes motoristas. 2. **Motoristas do Navegador**: Aqui é enviado os pedidos. Nesta arquitetura de driver do Selenium web, será conectado ou enviado o pedido a esses motoristas, então, de acordo com a plataforma e diferentes sistemas, você pode usar diferentes motoristas do navegador (por exemplo, Chrome, Firefox, Opera, Safari). Existiu uma mudança na versão mais recente quanto ao Internet Explorer, com o driver h (h driver) disponível ao invés disso. Os motoristas serão conectados ao navegador real (por exemplo, Chrome, Firefox) por meio do HTTP para realizar as ações solicitadas, abrir websites e interagir com eles. ## Linguagens de Programação e Bibliotecas Cada linguagem possui suas próprias bibliotecas: - Para Java: Baixar alguns binários ou arquivos JAR para serem referenciados no código-fonte. - Para Ruby: Bibliotecas de terceiros ou bibliotecas compartilhadas disponíveis. - Para Python: Disponível em forma de módulos. - Para C#: Bibliotecas específicas. - Para JavaScript: Bibliotecas específicas. Essas bibliotecas são necessárias para obter toda a interface do Selenium e utilizar suas características. ### Protocolo JSON Wire, Bibliotecas de Cliente e Motoristas do Navegador Através das bibliotecas de cliente, será enviado requisições para os motoristas do navegador, facilitando a transferência de dados entre servidor e cliente. Isso ajuda na execução de scripts para obter a saída desejada. Se você executar um navegador do Chrome específico usando o driver do Chrome, verá um navegador do Chrome sendo inicializado, e o website fica acessível, mostrando todo o sequence de comunicação e a arquitetura. # Selenium WebDriver com Eclipse: Configurar o seu Ambiente Para manter um manutenção ou controle apropriado, é necessário ter alguns componentes essenciais, incluindo especialistas em áreas específicas. Aqui estão os requisitos que podem considerar: 1. **Teste de compatibilidade de browser: ** O Selenium permite o teste de compatibilidade cruzada entre os browsers, permitindo o manuseio de requisições diferentes em diversos browsers. 2. **Teste de imagem: ** A teste de imagem não é directamente apoiado pelo Selenium sozinho. Integre-o de forma segura ao seu setup de Selenium para testar as imagens. 3. **Integrar ferramentas: ** Em alguns casos, o Selenium talvez não seja suficiente para determinadas tarefas. Integrar outras ferramentas para ter uma solução completa para suas necessidades. 4. **Mechanismo real: ** Embora não exista exatamente uma ferramenta única para lidar com todas as funções, poderá integrar ferramentas e componentes para alcançar uma solução completa. Aqui, vamos demonstrar como usar o Selenium WebDriver com o Eclipse para a execução de scripts de teste. Para isso, necessitamos dos seguintes componentes: 1. **Java Development Kit (JDK): ** - [Baixe o JDK 8](https://www.oracle.com/java/technologies/javase-jdk8-downloads.html) - A versão mais estável é recomendada. - Verifique se a sua versão de JDK escolhida é compatível com o seu browser e o Eclipse tool. 2. **Eclipse IDE: ** - [Baixe o Eclipse IDE para Desenvolvedores de Java](https://www.eclipse.org/downloads/eclipse-packages/) - Escolha a plataforma e a arquitetura apropriada. Depois de baixado, siga o processo de instalação. Será necessário o Java Runtime Environment (JRE) instalado antes de continuar com o Eclipse. Com os componentes em vigor, vamos prosseguir com as configurações: ## Configuração de Eclipse ### Configuração de Java 1. Defina o caminho do JDK em Eclipse: - Acesse **Janela > Preferências > Java > JREs instaladas. ** - Clique em **Adicionar. . . **, selecione **JRE Sistema de Library**, **Standard VM**, e escolha a JDK instalada. ### Configuração do Selenium WebDriver Sigam estes passos para integrar Selenium ao seu projeto de Eclipse: 1. Baixe os JARs dos Java bindings do site [Selenium](https://seleniumhq.github.io/selenium/downloads.html). 2. Descompacte os ficheiros JAR descarregados e inclua-os no classpath do seu projeto. 3. Configurar drivers separadamente, de acordo com o browser que está a usar (Chrome, Firefox, etc. ). Instale os respectivos drivers para a sua plataforma e adicione-os ao classpath do seu projeto. # Guia para a Utilização de um Bind de Linguagem no Eclipse com exemplo de Selenium ## Visão Geral Neste guia, vai aprender a utilizar um bind de linguagem num projeto Java no Eclipse com Selenium para automatizar a verificação de testes de navegadores web. ## Pré-requisitos - Java Development Kit (JDK) 1. 8 - IDE do Eclipse - Bind de Linguagem do Selenium (Descarregue disponível [aqui](https://seleniumhq.github.io/selenium/downloads.html)) ## Baixando e Instalando o Bind de Linguagem 1. Execute para a página de downloads do Selenium e seleccione a versão estável do bind de linguagem para a sua linguagem de programação. O bind será descarregado como um ficheiro . zip. 2. Extraia o ficheiro descarregado e mantenha-o numa biblioteca compartilhada ou nas pastas do projeto para facilitar o acesso. ## Criando um Projeto Java no Eclipse 1. No Eclipse, crie um novo projeto Java ir para `Ficheiros > Novo > Projeto Java`. 2. Nomeie o seu projeto (por exemplo, `selenium`). 3. Adicione as bibliotecas necessárias para JDK 1. 8 seguindo as configurações de JDK no Eclipse. 4. Se quiser adicionar quaisquer caminhos personalizados para JDK ou JRE, terá a oportunidade de fazê-lo nas definições de configuração do projeto. ## Importando o Bind de Linguagem para o Projeto 1. Abra o projeto Java anteriormente criado. 2. Ir para `Fonte > Configurar Caminho de Compilação > Adicionar Jars Externos`. 3. Adicione o ficheiro jar combinado do cliente (por exemplo, `selenium-3. 141. 59. jar`) que descarregou anteriormente. Este ficheiro jar resolve a maioria dos erros de importação. 4. Os ficheiros jar dependentes necessários para o bind de linguagem também estão disponíveis nos pasta's de biblioteca do ficheiro . zip, então importe-os conforme necessário. ## Configurando o Motor de Dados 1. Clica com o botão direito no seu projeto e vá para `Caminho de Compilação > Configurar Caminho de Compilação > Bibliotecas`. 2. Adicione o caminho para o ficheiro . jar do motor de dados executável do Selenium (por exemplo, `client-combined. exe` para um sistema em 64 bits do Windows). 3. Configure o navegador web pretendido (por exemplo, Firefox, Chrome) definindo o adjustedor appropriado para o navegador pretendo utilizar. 4. Se estiver a utilizar o navegador Firefox, baixe o adaptedor para o Firefox na sua página oficial e defina o seu caminho na configuração do projeto. ## Criando um Ficheiro de Classe para Testar a Functionalidade do Selenium 1. No projeto Java, crie um package chamado `calm` e em seguida cria um ficheiro de classe dentro deste package (por exemplo, `SeleniumTest`). 2. Escreva o código de espectadorespara testar a sua funcionalidade de Selenium. 3. Asegure-se de importar cada classe Selenium necessária no ficheiro de classe. 4. Defina o motor de dados num ficheiro de classe pelo criar uma instancia da classe do adaptedor de dados (por exemplo, `FirefoxDriver`, `ChromeDriver`). Quando concluir estes passos, deverá ser capaz de executar os seus testes de Selenium dentro do Eclipse utilizando o motor de dados de sua seleção. Feliz programação! # O Que É o Selenium? | Introdução à Selenium | Selenium | Simplilearn Este é um tutorial de vídeo sobre o **Selenium**, uma ferramenta de automação de aplicações web. Neste tutorial, você será guiado na primeira parte do caminho desta ferramenta. Antes de começar a entender qualquer ferramenta de automação, é importante se lembrar do que é teste manual e de seus desafios. Com o Selenium, os desafios do teste manual são superados. ## Teste Manual e seus desafios O teste manual é o método mais antigo de testar um software. Não requer conhecimento de ferramentas de automação e pode testar qualquer aplicação. Para entender os desafios do teste manual, podemos levar como exemplo um teste de login usual, como acessar um site utilizando um nome de usuário e senha. Utilizando testes de dados válidos, inválidos, vazios e outros, além de testar outros links e funções apresentadas e validar ganchos, mensagens de erro e teste de acessibilidade, existe um longo processo de manualmente executar testes e validar suas respostas. Este processo é épico e muito tempo consumidor, o que faz com que seja bem tedioso para qualquer testing manual. Além disso, possui um alto grau de erros com erros humanos sendo inerentes. Quando se trata de testes complexos, o processo rapidamente se torna tedioso e tedioso. ## O que é o Selenium? O Selenium é uma suíte de ferramentas para automação de testes de aplicações web. Ele não é uma ferramenta única e tem vários componentes que serão abordados neste tutorial. ## Vantagens e desvantagens do Selenium Como qualquer outra ferramenta de automação, o Selenium também tem suas vantagens e desvantagens. Nas próximas seções, iremos abordar suas vantagens e limitações, além de discutir a demanda do mercado relacionada à Selenium. ## O Selenium nos cenários de trabalho Como crescente o uso de automação em sua empresa, veja como a Selenium pode ajudar você a causar um impacto significativo nos seus testes. ```bash # Instalação do Selenium java -jar selenium-server-standalone-3. 141. 59. jar ``` Como você não precisa fazer testes manualmente, a Selenium reduz o tempo descocfeiro do Departamento de Teste, liberando recursos para o lado oficial e mais importantes da empresa. --- Se usted siente que esto es útil, por favor subscriba al canal de YouTube de [Simplilearn](https://www.youtube.com/channel/UCjKcuGAs8m_8m0U8Yjxk8jg) para saber mais! Para aprender mais sobre o Selenium, recomendamos a nossa [curso oficial de Selenium WebDriver do Simply Lear](https://www.simplilearn. com/selenium-webdriver-tutorial)! [Lembre-se de obter sua certificação em Selenium WebDriver! ](https://www.simplilearn. com/certification-programs/selenium-webdriver) > O exemplo fornecido não foi originalmente escrito em inglês, talvez existam alguns erros de pontuação e gramáticos. # Introdução ao Selenium O Selenium é uma ferramenta de automação popular e amplamente utilizada para automatizar testes de aplicações web. Ele nos permite testar aplicações web em diferentes navegadores, como Internet Explorer, Chrome, Firefox, Safari, Edge e mesmo navegadores sem interface gráfica (headless browsers). O **Selenium** é uma ferramenta aberta e independente do sistema operacional que se tornou um dos maiores poderes de teste de aplicações web. A principal razão de sua popularidade é que é de código aberto, enquanto que ferramentas como QTP e RFT, mencionadas anteriormente, são pagas. O Selenium é uma conjuntura de ferramentas e bibliotecas para facilitar a automação de aplicações web. Não é apenas uma ferramenta; é constituída por vários componentes, dos quais vamos falar em detalhe. Você pode executar scripts do Selenium em qualquer plataforma, fazendo-o independente do sistema operacional, pois é desenvolvido em JavaScript. ## O que é o Selenium? O Selenium é uma ferramenta de automação de testes de aplicações web, permitindo o teste de aplicações web em diferentes navegadores como IE, Chrome, Firefox, Safari, Edge, e até navegadores sem interface gráfica (headless browsers). ## Componentes do Selenium O Selenium contem vários componentes, e esta seção fornece uma visão mais detalhada de cada um deles e como eles funcionam: ### Selenium Integrated Development Environment (IDE) O Selenium IDE é o Ferramenta Simples do conjunto do Selenium. É um Integrated Development Environment (IDE) com funcionalidade de gravação e reprodução, tornando-o fácil e simples de usar, embora seu uso seja principalmente para protótipos e não para a criação de scripts de automação reális em projetos de tempo real devido às suas próprias limitações. Como o Selenium IDE é apenas uma ferramenta de gravação e execução, possui várias limitações. No entanto, se os testadores não possuírem conhecimento suficiente para começar, ainda existe este IDE, uma ferramenta de gravação e reprodução, que pode ser usada para criar scripts testes simples. O Selenium IDE está disponível como uma extensão de plugin no Firefox e como uma extensão no Chrome, portanto, qualquer dos dois navegadores Firefox ou Chrome pode ser usado para gravar scripts de teste. Aqui está como o Selenium IDE se parece: ! [Selenium IDE](https://your-path-to-screenshot.com/se-ide-screenshot.png) ### Selenium Remote Control (RC) O Selenium Remote Control (RC) é outra parte do conjunto do Selenium. Esta parte interage com o browser utilizando um servidor RC, que suporta múltiplas linguagens de programação como Java, C, Perl, Python, PHP, e JavaScript. O Selenium RC é escrito em Java e utiliza requisições HTTP simples GET e POST para comunicação. A partir do Selenium 3. 0, o Selenium Remote Control (RC) foi descontinuado, e não o encontrará em versões mais recentes. Alternativamente, você ainda pode utilizar o `Selenium WebDriver` e `Selenium Grid`. ### Selenium WebDriver O Selenium WebDriver é uma substituição para o Selenium Remote Control (RC) e uma poderosa ferramenta para testar aplicações web utilizando diferentes linguagens de programação como Java, C#, Python, Ruby, ou JavaScript. WebDriver fornece uma API de programação para interagir diretamente com browsers, enquanto o RC utilizava o servidor RC para interagir com browsers. ### Selenium Grid O Selenium Grid é um framewor de testes distribuído que permite a execução de testes em várias diferentes ambientes, executando casos de teste em paralelo em diferentes máquinas virtuais (máquinas virtuais), em navegadores reais, ou sistemas operacionais. O Grid ajuda a realizar testes de multi-navegador e testes em paralelo sem escrever nenhum código específico. # Selenium Remote Control (RC) e Selenium WebDriver: Introdução Este documento fornece uma visão geral de Selenium Remote Control (RC) e Selenium WebDriver, dois tópicos populares para automatizar navegadores web. ## Selenium Remote Control (RC) ### Arquitetura O Selenium Remote Control (RC) é um servidor de controle remoto que atua como um proxy, permitindo que sua parte central (o núcleo do Selenium e aplicação web sob teste) e o navegador acreditem estar em domínio K. Isso elimina a Política da Origem Comum. A arquitetura do Selenium RC consiste nos seguintes componentes: 1. **Scripts de teste**: Estes são os scripts que você vai escrever em qualquer idioma de suporte, como PHP, Java, Python, e Ruby. 2. **Servidor RC**: Este é uma aplicação separada que é instalada no seu sistema. Ele é responsável por receber os comandos do Selenium de suas scripts de teste, interpretá-los, e executá-los em seu navegador. Os resultados são então enviados de volta para suas scripts de teste. 3. **Navegador**: O navegador onde a automação ocorre. ### Limitações O Selenium RC possui algumas limitações, incluindo: 1. **Arquitetura complexa**: O servidor RC intermédio entre o navegador e suas scripts de teste complica a arquitetura. 2. **execução lenta**: A execução de comandos demora muito porque precisam ser feitas viagens inteiras de suas scripts de teste para o servidor RC, o núcleo, e de volta ao navegador para cada comando. ## Selenium WebDriver ### Introdução O Selenium WebDriver foi introduzido para superar as limitações do Selenium RC. É uma interface de programação para criar e executar casos de teste, fornecendo várias técnicas de localização para localizar elementos web e interagir com eles. O WebDriver não necessita de um módulo de nucleo como o RC e interage de forma nativa com a aplicação do navegador, eliminando a necessidade do servidor RC intermédio. ### Vantagens 1. **Arquitetura mais simples**: O WebDriver possui uma arquitetura mais simples devido à interação nativa com a aplicação do navegador. 2. **execução mais rápida**: A comunicação direta entre o navegador e o sistema operacional resulta em uma execução de testes mais rápida em comparação com o RC. ### Bibliotecas de cliente e controladores de navegadores O Selenium WebDriver suporta diversos idiomas e tem integração com diversas frameworks. Você pode baixar as bibliotecas de cliente para o idioma preferencial do seu site no [seleniumhq. org](http://seleniumhq.org) site. Em cada navegador com suporte, existe um arquivo de controlador correspondente disponível. Estes controladores interagem com o navegador real, estabelecendo uma ligação sem revelar a lógica interna do controlador de funções do navegador. ### Selenium Grid Para reduzir o tempo de execução de testes, o Selenium fornece o Selenium Grid. Este grid é destinado a distribuir comandos em várias máquinas simultaneamente em um ambiente real-time. Isso permite a execução paralela de testes em vários navegadores e sistemas operativos, reduzindo o tempo de execução. ### Conceito Hub e Nó O Selenium Grid funciona sob um conceito hub e nó. Você define uma máquina mestra (também conhecida como um hub) executando um servidor do Selenium standalone. Este servidor pode ser baixado no [seleniumhq. org](http://seleniumhq.org) site. Com o servidor, você cria uma configuração do hub e nós especificados de acordo com suas necessidades. Quando você tem o ambiente do master estando criado, você pode controlar em qual nó executar cada teste. Por exemplo, você pode querer executar testes em todos os navegadores e sistemas operacionais com suporte. Com o Selenium Grid, você pode executar testes paralelamente em vários navegadores e sistemas operacionais, o que significa um significativo redução no tempo de execução de testes. --- Este documento oferece uma visão geral de alto nível de Selenium Remote Control (RC) e Selenium WebDriver. Para informações detalhadas, consulte a documentação oficial do Selenium. # Curso de Auto Selenium 2023 | Tutorial de Auto Selenium para Iniciantes | Tutorial de Auto Selenium | Simplilearn --- ## Introdução ao WebDriver do Selenium ### Introdução Bem-vindo ao Tutorial do WebDriver do Selenium por Simplilearn! Neste vídeo, vamos abordar os conceitos básicos do WebDriver do Selenium, sua evolução e por que utilizar o WebDriver. Estaremos também discutindo desvantagens da testação manual e como a automação ajuda. Em seguida, vamos fazer um dic loving no WebDriver de arquitetura, suas vantagens e limitações, e ilustrar em ação utilizando um caso de uso de uma aplicação web simples para automatizar. <! -- Passeemos por uma breve vista dos inconvenientes da testação manual --> ### Por que a testação manual é ineficiente - Demora muito tempo e é aborrecida - Suscível a erros humanos - Limitação de alcance - Difícil trabalhar com grandes amounts de dados - Desafios na teste de performance e na criação de relatórios de testes <! -- Quando trabalhando com modelos Agile, o caráter casual e aborrecido da testação manual pode se tornar uma desafio grande, tornando a automação uma solução atraente --> ### O nascimento do Selenium: Endirendo a necessidade de automação O Selenium foi introduzido por Jason Huggins em 2004, enquanto trabalhava como engenheiro na ThoughtWorks. Ele desenvolveu um programa de JavaScript chamado o "Test Runner de JavaScript", que automatizou ações do navegador, que mais tarde se tornou conhecido como o Selenium Core. ### WebDriver do Selenium: Características chave - Provérvelmente usado como ferramenta de automação para testes de aplicações web - Apresenta suporte para diversos navegadores e sistemas operativos, incluindo navegadores sem visualização - Open-source, gratuito para uso e disponível para várias linguas de programação - Ajudante na execução em paralelo e alcançando cobertura de teste ampla - Fornece recursos de reutilização e integração com add-ons <! -- Exploremos algumas limitações do WebDriver do Selenium e aprenda-as como trabalhar por elas --> ### Endirendo as limitações do WebDriver do Selenium - Capacidade de relatórios limitada, mas pode ser melhorada ao integrar ferramentas como TestNg, Relatórios de Extent - Não apresenta capacidade de gerenciamento de testes, mas pode ser integrada com a ferramenta de gerenciamento de teste utilizada na sua organização - Não pode gerenciar a automação de aplicações móveis ou de desktop, mas pode ser integrada com ferramentas como APM para testes móveis - Limitação em testes de imagem, mas pode ser melhorado ao integrar ferramentas como AutoIT e Securely ### Conclusão O WebDriver do Selenium é uma poderoso automatizador para testes de aplicações web, com suas próprias vantagens e limitações. Com o entendimento destas, podemos trabalhar em torno das limitações e aplicar o WebDriver do Selenium de forma eficaz. ### Ações Recomendadas 1. Verifique nossos vídeos para dominar a escrita de scripts de automatização. 2. Aprenda de documentações extensas e fórums disponíveis. 3. Considere integrar o Selenium com ferramentas de gerenciamento de testes para melhorar suas capacidades. Espero que gostaste deste vídeo! Não esqueça de assinar o canal do YouTube da Simply Learn para mais vídeos como este! --- Note: Lembre-se de atentar a URL, formatação e correta utilização de elementos de marcação de Markdown como cabeçalhos, bloqueios de código, listas e parágrafos. # Selenium: Guia Comumente Utilizado para Teste de Aplicativos Web O Selenium é uma coletânea de ferramentas poderosa para facilitar a automação de aplicativos web. Não é uma ferramenta individual, mas sim a coleção de componentes que ajudam a testar eficientemente aplicativos web. Este guia apresentará um resumo dos componentes de Selenium e sua utilização. ## Sumário 1. [Introdução](#introduçao) 2. [Componentes de Selenium](#componentes) - [Selenium IDE](#ide) - [Selenium RC (Controlo Remoto)](#rc) - [Selenium WebDriver](#webdriver) - [Selenium Grid](#grid) 3. [Versões e Evolução](#versoes) 4. [Começando](#começando) <a name="introdução"></a> ## 1. Introdução O Selenium é um kit de ferramentas abertas e independente de plataforma desenvolvido para a automação de aplicativos web. Sua popularidade se atribui à sua flexibilidade, eficiência e suporte a plataformas multi-línguagens. Desta forma, é importante notar que, embora o Selenium principalmente seja desenvolvido em JavaScipt, ele suporta vários idiomas de programação, incluindo Java, Python, C#, Ruby e PHP. Um dos pontos fortes do Selenium é sua aplicabilidade para testers manuais com um fundamento de programação mínimo. O Selenium oferece um teste de gravação e repetição chamado Selenium IDE, permitindo que os usuários criem scripts de teste gravação e replicando-os. Porém, a verdadeira potência do Selenium resume-se a utilizar todos os seus recursos, não apenas o teste de gravação e repetição. <a name="componentes"></a> ## 2. Componentes de Selenium O Selenium consiste em vários componentes principais que trabalham juntos para facilitar o teste de aplicativos web. ### <a name="ide"></a>2. 1 Selenium IDE O Selenium IDE é o elemento mais simples do conjunto de ferramentas de Selenium. É um Ambiente de Desenvolvimento Integrado (IDE) que oferece uma funcionalidade de gravação e reprodução, anteriormente disponível como uma extensão do Firefox. O IDE é ideal para prototipos ou fins de demonstração, mas não é recomendado para a criação de automação em projetos de tempo real. A partir do Firefox 55, o suporte ao IDE foi descontinuado. No entanto, uma nova versão do Selenium IDE foi lançada recentemente, suportando ambos os navegadores Chrome e Firefox. #### Chrome de Instalação 1. Pesquise "Selenium IDE para Chrome" no seu navegador. 2. Vá ao site SelenuimHQ. org. 3. Clique em " Adicionar à Chrome " para instalar a extensão no seu navegador Chrome. #### Firefox Instalação 1. Va para seu navegador Firefox. 2. Pesquise "Selenium IDE". 3. Instale o ad-on disponível. ### <a name="rc"></a>2. 2 Selenium RC (Controlo Remoto) O Selenium RC (Controlo Remoto) é utilizado para escrever testes de aplicativos web em várias linguagens de programação. Ele interage com navegadores através de um Servidor RC, utilizando mensagens HTTP GET e POST simples. O Selenium RC foi substituído pela WebDriver na versão 3. 0. ### <a name="webdriver"></a>2. 3 Selenium WebDriver O Selenium WebDriver é o componente mais importante e o sucessor do RC. Ele oferece uma interface de programa para criar e executar casos de teste. O WebDriver comunica diretamente com o navegador, fornecendo vantagens sobre o RC graças ao seu arquitetura simplificada. ### <a name="grid"></a>2. 4 Selenium Grid O Selenium Grid é utilizado para executar vários scripts de teste em várias máquinas simultaneamente, garantindo tempos de execução mais rápidos. Com o WebDriver, é possível somente executar testes de scripts sequencialmente; no entanto, em cenários reais, múltiplos scripts de teste precisam ser executados em ambientes distribuídos, como navegadores e sistemas operativos diferentes. O Selenium Grid ajuda a alcançar execução em paralelo utilizando a abordagem hub-node. <a name="versoes"></a> ## 3. Versões e Evolução O Selenium evoluiu significativamente desde a sua criação original. A seguir, alguns pontos resumem as principais versões do Selenium e suas características identificadas. ### Selenium 1. 0 A primeira versão de Selenium criada por Jason Huggins era chamada de "JavaScript Program" ou "JavaScript Test Runner. " Ele teve um problema relacionado à "Política SAMEORIGIN", que foi resolvido por Paul Hamming's criação de um Servidor Selenium RC (Controlo Remoto). ### Selenium 2. 0 Em 2007, Simon Stewart introduziu a WebDriver com o objetivo de eliminar a necessidade de um servidor separado no RC e estabelecendo Selenium 2. 0, representando uma fase de transição, com ambos o Selenium RC e a WebDriver co-existindo. ### Selenium 3. 0 Em Selenium 3. 0, o Selenium Core (RC) foi descontinuado e apenas a WebDriver disponibilizada. Esta versão é o foco desta série de vídeos. Selenium 4 já é em estado dealpha, com recursos como normalização da WebDriver W3C, uma nova versão do IDE melhorada e uma melhoria Selenium Grid esperados. <a name="começando"></a> ## 4. Acomeçando Este guia serve como uma introdução ao Selenium e seus componentes. Para uma compreensão mais profunda e experiência prática, consulte recursos adicionais e tutoriais disponíveis online. Esta é apenas a introdução ao seu percurso com o Selenium! # Selenium WebDriver vs. Selenium RC: uma Comparação Este artigo apresentará as diferenças entre Selenium RC e Selenium WebDriver, enfocando suas arquiteturas, complexidades dos APIs e velocidade. ## Selenium RC O Selenium RC, iniciado em 2004, é uma arquitetura complexa devido à presença de um servidor RC intermediário que se comunica com o navegador. Essa arquitetura não possui interação direta com o navegador, obrigando a utilização de um servidor RC adicional para a mediados a comunicação entre os comandos Selenium e o navegador, o que resulta em uma executação lenta dos testes de automação. Outro desvantageiro do Selenium RC é seus APIs, que não são tão intuitivos quantos os fornecidos pelo Selenium WebDriver. Os APIs no Selenium RC podem ser redundantes, confuosos e sensíveis à interpretação de diferenças de navegador, fazendo com que os desenvolvedores encontram difícil escrever scripts de testes de browser cruzados e utilizar seus casos de teste estáveis. ## Selenium WebDriver Introduzido por Simon Stewart em 2006, o Selenium WebDriver apresenta uma arquitetura simplificada comparado ao Selenium RC. Ele principalmente consiste em scripts de testes, um navegador web e um servidor web. Diferentemente do Selenium RC, não requer um servidor adicional para comunicação, resultando em uma execução mais rápida de testes de automação. Outro vantagem do Selenium WebDriver é a sua provisão de um API maduro e mais simples de utilizar. Ele oferece comandos diretos para tarefas como simular ações de clique, enviar texto e scroll vertical em páginas web. O Selenium WebDriver também suporta vários navegadores, incluindo Firefox, Chrome, Opera, Safari, Edge, Edge, e navegadores sem interface de usuário, como o HTML Unit. Os navegadores sem interface de usuário são mais rápidos pois não exigem um navegador real para testar. ## Componentes do WebDriver O Selenium WebDriver consiste em quatro componentes principais: 1. Libraries de Cliente/Binding de Linguagem: Estas bibliotecas permitem aos desenvolvedores criarem scripts de automação em várias linguagens de programa suportadas, como Java, Python, etc. As bibliotecas se podem baixar do website do Selenium. 2. Protocolo JSON Wire: Este protocolo é utilizado para a troca de informações na web, e todas as interações com os controladores de navegadores acontecem através de pesos JSON e pedidos HTTP. 3. Controladores: Estes componentes específicos de navegador estabelecem contatos com os navegadores reais sem revelar a lógica interna, executando comandos no navegador e retornando os resultados. 4. Scripts de Testes: Os scripts de testes são criados usando elementos web ou objetos na web, usando os locadores do Selenium WebDriver e os métodos do Selenium WebDriver. A medida que aprende o Selenium, você aprenderá esses métodos do WebDriver e as técnicas de localização utilizadas para as ações nos elementos do web. ## Limitações do WebDriver de Selenium Apesar de que o Selenium WebDriver resolver muitos problemas vistos no Selenium RC, ainda possui algumas limitantes: 1. Testes de Aplicações Móveis: O WebDriver de Selenium se concentra na automação de aplicações web e não pode gerenciar aplicações móveis de forma direta. No entanto, ele oferece suporte à integração de ferramentas populares de automação de testes de aplicações móveis como o Appium. 2. Execução Paralela: Embora o WebDriver possa executar operações sequenciais, testes de cenário real exigem a execução em execução concorrente em várias máquinas e processos. Essa limitação é tratada pela Gride do Selenium, que habilita a execução concorrente e será discutida em vídeos seguintes. 3. Capacidade de Reportar: O WebDriver de Selenium apresenta recursos de reportagem simples, mas para projetos maiores que necessitaram de informações de relatório mais completas, a integração com ferramentas como TestNG ReportNG e Extent Reports pode ser empregada para gerar relatórios mais detalhados. 4. Testes de Imagens: O WebDriver de Selenium apresenta suporte limitado para testes de imagens, principalmente projetados para a automação de aplicações web. No entanto, ferramentas adicionais como o AutoIT podem ser empregadas em conjugação com o Selenium para alcançar requisitos de testes de imagem. Em resume, embora Selenium RC e Selenium WebDriver tenham semelhanças, a simplicidade arquitetural, o API refinado e suporte ao múltiplo de linguagens e frameworks do WebDriver o convertem num poderosa ferramenta para automater aplicações web. A discussão da arquitetura, componentes e vantagens e limitações do Selenium WebDriver fornece uma fundação sólida para compreender a ferramenta e se preparar para exercícios de mãos-á-penas com ela. # Guia Compreensivo para Automação de Web com WebDriver no Selenium Este documento oferece uma visão geral da plataforma Selenium e das capacidades que fornece para automação em web, especialmente pelo WebDriver. Iremos discutir algumas commandos de navegadores e funciones básicas que utilizaremos nosso nosso demonstrativo. ## Conhecimento das commandos e funções do Navegador ### Comandos Básicos e Funcionais de Navegadores - `driver. get("url")`: Abre quaisquer website ou aplicação com URL especificada. - `driver. getTitle()`: pega o título da web página em que trabalhamos. - `driver. getCurrentUrl()`: impressiona a URL corrente na console. Esta função é bastante útil para a realização de manipulação multi páginas web. - `driver. getPageSource()`: Armazena o fonte completo da web HTML na console. esta função raramente usada para trabalhos relacionados ao conteúdo que você pretender visualizar da páginas html suas. - `driver. manage(). window(). maximize(); `: Maximiza a janela do browser. - `driver. close()`: fecha a janela atual de navegador. - `driver. quit()`: deixa a total sessão do navegador. ### Comandos de navegação - `driver. navigate(). back()`: Navega para uma página anterioada. - `driver. navigate(). forward()`: Navega para próxima página. - `driver. navigate(). refresh()`: Refresh o browser pagínas web. ### Comandos para a Interação dos elementos - `driver. findElement(By. id("elementIdOrLinkText"))`: Isto é um comando que serve para qualquer elemento que é reconhecido com os identificadores da Web. - `JavaScriptExecutor myExecutor = (JavaScriptExecutor) driver; myExecutor. executeScript("clica no botão"); `: Isto é um comando que pode utilizado clique em botões ou aciónes em JS na área com o botão de atribuição na WebElement . ## Teste Case de exemplo: Ebay pesquisar Neste caso de uso de exemplo vamos usar Selenium para busca de produto na eBay e de teste para vér o as promoções disponíveis. ```java import org. openqa. selenium. By; import org. openqa. selenium. WebDriver; import org. openqa. selenium. firefox. FirefoxDriver; import org. testng. annotations. Test; import org. testng. annotations. BeforeTest; public class EbaySearchTest { private WebDriver driver; @BeforeTest public void setup() { //Configure o navegador para Firefox para Selenium. System. setProperty("webdriver. gecko. driver", "geckodriver"); //Mude para a path certificado para a sua sistema de arquivos operativa driver = new FirefoxDriver(); //Maximizar a jána web de navegação. driver. manage(). window(). maximize(); } @Test public void testePesquisasWebDriver() { //Carrega o eBay pagina principal. driver. get("https://www.ebay.com"); //Buscar JBL aludifonia. WebElement buscadorPesquisa = driver. findElement(By. id("gh-ac")); WebElement buttonBuscadorPesquisa = driver. findElement(By. id("gh-ug")); buscadorPesquisa. sendKeys("JBL aludifonia"); buttonBuscadorPesquisa. clica(); //checar disponíveis em promoções WebElement descontoPromocoes = driver. findElement(By. id("C4")); assertNotNull(descontoPromoc # Selenium Webdriver e Selenium IDE: Introdução e funcionalidades Básicas ## **Objetivos do vídeo** - Praticar sobre os conceitos e funcionamentos mais comuns do Selenium. - Implementar teste funcional nos elementos inúmeros e complexos utilizando o próprio IDE de Selenium. ## Como instalar o próprio Ide do Selenium 1. **Acceder ao Download: ** Para instalar o aplicativo web da IDE, acesse https://wiki.openqua.la/display/SED/Index para baixar o módulo compilado ideal para seu web-browser desejado (i. e. : FireFox, Chrome etc. ). Instale. ! [ide-screen-shot. png](link da imagem de captura) ! [image-add](link para o segundo compartilhar da imagem de captura) 1. **Irá aparecer ao lado**: O ícone do FireFox será visualizado automaticamente no próprio Navegador e serão ativadas as funcionalidades IDE! _NOTA: _ Para a criação deste vídeo, você pode acessar em www. test-automating-webui-using-selenium. com as lições pertinentes como 'Baixando e Utilizando com IDE web (Selenium Eclipse)'! #### Comandos úteis e funcionamentos necessários que saber utilizar Lista de uma das funcionais fundamentais é de: (as funcções mostradas abaixo são disponibilizadas por padrão). 1. Obtendo documentos HTML / Páginas do site atual `document. get document element (" ")` – captura inteiramente a aparência na `<BODY />` 3. Obtain tags HTML element específicas _TIP1: `elementsByName` obtém todos os componentes HTML referentes ao NOME específico _ TIP 2: obter todos seletores seletores Xpath 6. Obtainment CSS selecotores relacionados na seleção ativa ## Selecções de Clique Talvez a seleção obtida depois da consulta de cada uma das fórmulas acima não se tenha obtido o elemento correto `<id/>`, isto é se não estiver corretamente selecionado, o WebElement poderá precisar também obter todas as nossas selecções de apração - usando-as para automação. Utilizar o conector ``. `` para executar a específica seleção. As `<link-text` / `XPath`, ` <value> ou id` , cada um em parêntesis. Como referência. . . | Tag | Efeito geral | Ações | Navegações | |-----|----|------|---| 1. `Driver. findbyXpath " ` | Função para apagar componentes HTMLs na página | Remove / deixa paralisado de qualquer web-element/ <tag do nome> </p> com as especificidades de com o X-Path | Sem direção à próxima ação por parte do conteúdolista web, apague de forma global apenas este comando seleção. Sem `. send keys` se torna impresivo quanto à operações de deselecionados. Apresentado pelo próximo exemplo: `<table. find( "//name()"">"` ! [screensh ](screenshot link aqui) # Selenium IDE: Melhoria na funcionalidade dos Locators e mais O Selenium IDE é uma ferramenta útil para propósitos de prototipagem ou demonstração, pois oferece capacidades potentes para criar scripts de teste. Enquanto o Selenium WebDriver a si próprio é capaz de criar scripts de teste robustos, o IDE permanece principalmente como uma ferramenta de prototipagem devido à sua velocidade na criação de casos de teste. Neste documento, abordaremos as vantagens e recursos do Selenium IDE. ## Vantagens do Selenium IDE - Nenhuma conhecimento de programação necessário - Ideal para escrever scripts de teste rápidos para propósitos de demonstração - Suporta ambos os navegadores Google Chrome e Mozilla Firefox (compatibilidade entre navegadores) ## Instalação ### Chrome: 1. Abre o seu navegador Chrome. 2. Pesquise por "Selenium IDE para Chrome". 3. Vá para a página da extensão em chrome. google. com. 4. Clique em "Adicionar ao Chrome". 5. Espere até que a extensão seja adicionada ao seu navegador Chrome. 6. Você pode verificar se adicionou-se corretamente verificando se o ícone do Selenium IDE está presente na sua barra de ferramentas. ### Firefox: 1. Instale o Selenium IDE para Firefox como um plugin. 2. Para usar o browser Firefox para demos neste documento, asegure-se de que o mesmo já esteja instalado. 3. Para abrir o IDE, clique no ícone de plugin na sua barra de ferramentas. 4. O IDE abrirá uma janela onde você pode abrir um projeto existente, criar um novo projeto ou iniciar a gravação de um novo caso de teste. ## Recursos do Selenium IDE ### Melhoria na funcionalidade dos Locators Os locators são técnicas usadas para localizar elementos na sua página web. O Selenium IDE registra o nome do atributo de um elemento web ao gravar e reconhece o elemento particular usando esse atributo. Por sua vez, também registra vários locators disponíveis para esse elemento específico, como: - CSS Locator - Locator Expato Isto ajuda a tornar os casos de teste mais robustos ao cair na outra localização no estrutura se o localizador principal mudar. ### Execução Paralela Ao contrário do Selenium IDE tradicional, essa característica foi adicionada para melhorar a eficiência. ### Comandos de Controle nos Scripts O Selenium IDE suporta comandos de controle, como `if-else`, `while-loops`, `for-loops`, e `switch-case`, sem necessidade de plugins adicionais. ### Sincronização de Automatização O Selenium IDE se preocupa em fornecer tempo suficiente para garantir que todos os elementos de sua página web e a página que ela contém sejam carregados totalmente antes que mesmo uma linha de script seja executada. Ele também oferece uma opção de set speed global para controlar a velocidade de execução de seu script. ### Código Embutido Você pode executar um código simples em Java ou JavaScript de seu script de teste no Selenium IDE usando o comando "execute". ### Depurador O Selenium IDE possui um depurador que permite execução em passos, adição de pontos de interrupção, e uma opção "pausar em exceção" que interrompe a execução quando um campo de exceção for habilitado. ### Integração com CI Como os scripts podem ser executados da linha de comando, podem ser integrados com projetos Maven e executados através de Jenkins, alcançando a integração contínua (CI). ## Interface do Selenium IDE A interface do Selenium IDE consiste nas seguintes componentes: 1. Barra de Menus - Editar o nome do projeto, crie, abra ou salve o projeto atual 2. Barra de Ferramentas - Executar todos os testes - Executar somente o teste atual - Execução em passos (opção de depurador) - Pausar em exceção (opção de depurador) # Uso de Selenium - Gravação e Execução de Scripts de Teste ## Introdução Neste tutorial, vamos aprender a utilizar o Selenium WebDriver em Python para gravar e executar scripts de teste. ## Pré-requisitos - Instale Python - Instale o driver do navegador do Selenium ## Gravação de Scripts de Teste ### Passo 1: Abrir o Selenium IDE Vamos fechar esta janela e voltar à nossa janela do ID. Aqui, você encontrará botões onde pode dizer **Gravar** ou **Parar de Gravar**. ### Passo 2: Iniciar a Gravação Clique no botão **Gravar** para iniciar a gravação. Você verá o navegador aberto com a URL que especificou no campo de endereço da barra de endereços (por favor, garanta-se que insira uma URL válida). A partir daqui, você pode começar a gravar seu script. ### Passo 3: Executar Ações Execute as ações que deseja automatizar, como clicar em um botão, digitar texto ou afirmar o título. Essas ações serão gravadas como **comandos** no IDE do Selenium. ### Passo 4: Parar de Gravar e Salvar Parar a gravação clicando no botão **Parar de Gravar** quando terminar. Agora, você pode ver todos os comandos que foram gravados no **Painel de Caso de Teste**. ## Execução de Scripts de Teste ### Passo 1: Executar o Caso de Teste Para executar um caso de teste, clique no botão **Executar** no IDE do Selenium. Você verá o caso de teste listado no **Painel de Caso de Teste** durante a execução. ### Passo 2: Visualizar o Log e Resultados do Teste Após o caso de teste ter sido executado, você pode visualizar os resultados no **Log do Teste**. Comandos bem-sucedidos serão registrados em verde, enquanto comandos falhados serão em vermelho. ## Uso Avançado ### Re-gravação e Adição de Comandos Se você quiser re-gravar o script ou adicionar comandos no meio do script, você pode fazer isso clicando no botão **Gravar** novamente, e o script começará a gravar-se novamente do ponto atual. ### Comandos Manuais Você também pode adicionar comandos manualmente, em vez de re-gravar. Por exemplo, digamos que você queira adicionar um comando para clicar no carrinho, você pode fazer isso escrevendo o comando e selecionando o elemento alvo por si mesmo. ## Salvar Projetos Quando terminar, você pode salvar seu projeto clicando no botão **Salvar**. Todos os projetos são salvos como `. sid` arquivos, que podem ser abertos no IDE do Selenium. ## Exportando Casos de Teste Você pode exportar seus casos de teste em vários formatos (Java, JUnit, JavaScript, ou Python) clicando com o botão direito do mouse no caso de teste no **Painel de Caso de Teste** e selecionando **Exportar**. # IDE Antigo Possui Múltiplas Opções de Exportação Este IDE oferece múltiplas opções de exportação, incluindo scripts de driver Web e JavaScripts. Essas características estão ainda em desenvolvimento, e mais suporte para outras línguas de programação será adicionado no futuro. Por enquanto, as opções disponíveis são Java, JUnit, JavaScript e Python. Vamos prosseguir com a exportação deste para Java JUnit. Este caso simplesmente salvará o ficheiro como um arquivo . java. Permita que eu me Irei para o `id test` e guardar este ficheiro. Se regresse ao meu Finder, poderá encontrar o `search_iphone_test. java` ficheiro. Pode abrir o ficheiro Java, e verá ter sido exportado um teste JUnit simples. Se tiver um IDE Eclipse, poderá utilizar este teste e executá-lo do lado do seu Eclipse. ## Comandos Selenium Os comandos Selenium podem ser, grosamente, classificados em três categorias: 1. Comandos de Ação 2. Acessores 3. Aves de Verificação ### Comandos de Ação Os comandos de Ação são os comandos que interagem diretamente com os elementos da sua aplicação Web. Vamos ver alguns exemplos: ``` open setWindowSize clique type ``` No nosso exemplo anterior, escrevimos um script de teste para Amazon. Se olhar por tudo isto como `open`, `setWindowSize`, `clique`, `type`, estes são todos comandos de Ação. ### Acessores Os comandos de Acesso são os comandos Selenium que examinam o estado da aplicação e armazenam os resultados em uma variável. Estes comandos permitem à utilizador armazenar determinados valores nos suas variáveis do usuário definido, e estes valores podem ser posteriormente utilizados para a criação de ave de verificação ou pontos de verificação. Escrevemos algumas das comandos `store` em ação: ``` storeTitle storeText storeValue ``` ### Aves de Verificação As Aves de Verificação verificam o estado atual da aplicação com um estado esperado. Isso é onde comparam o resultado real com o resultado esperado. As Aves de Verificação são de três tipos diferentes: 1. Assert 2. Verify 3. WaitFor # Afluentes e Afirmações Suaves em Selenium IDE utilizando Markdown Afirmações Suaves interrompem a execução do teste assim que uma afirmação falha, enquanto Afirmações Suaves permitem que o teste continue e marque a falha no final. Este tutorial mostrará as diferenças entre afirmações suaves e afirmações duros utilizando exemplos. ## Afirmação Dupla ### Exemplo 1: Afirmação Falha na Titularidade Neste exemplo, criaremos uma caja de teste para demonstrar a falha de uma afirmação dupla. 1. Iniciar o gravador do Selenium IDE. 2. Navegar até o site da Amazon. 3. Selecionar com o botãodireito e escolher "Assert Title" para adicionar o comando. 4. Remover o comando desnecessário. 5. Modificar a titularidade para causar uma falha. 6. Executar o teste para observar a falha de validação. ```markdown # Caja de Testes: Título na Amazon (Afirmação Dupla) **Pré-requisito: ** Iniciar o gravador do Selenium IDE. **Passos: ** 1. Abrir o site: https://www.amazon.com 2. Ajustar o tamanho da janela 3. Afirmar Titularidade: (Esperado: "Amazon. com", Ativa: "<título incorreto>") **Resultado: ** A caja de teste falhará devido à fusão da titularidade. 4. (Nenhum outro comando será executado, pois o teste parará após a falha da afirmação. ) ``` ## Afirmação Suave ### Exemplo 2: Falha da Afirmação de Titularidade com Execução Continuada Neste exemplo, modificaremos a caja de teste anterior para utilizar uma afirmação suave, e observar a execução continuada, após uma falha. 1. Modificar o comando "Assert Title" para "Verificar Título. " 2. Executar a caja de teste para observar a falha da afirmação suave e execução continua. ```markdown # Caja de Testes: Verificar Titularidade na Amazon (Afirmação Suave) **Pré-requisito: ** Iniciar o gravador do Selenium IDE. **Passos: ** 1. Abrir o site: https://www.amazon.com 2. Ajustar o tamanho da janela 3. Verificar Título: "Amazon. com" **Resultado: ** A titularidade será verificada, e se for falhar, a caja de teste será marcada como uma falha à fim. 4. Clicar em "Best Seller" 5. Fechar o navegador ``` ### Exemplo 3: Aguardar Elemento Dinamicamente Carregado Neste exemplo, criaremos uma caja de testes para esperar um elemento dinamicamente carregado com o comando "Wait For. " 1. Criar uma nova caja de testes. 2. Abrir o site demo ([Elemento Dinamicamente Carregado Carregado](https://demoqa.com/dynamic-loading-example/)) para demonstrar um elemento dinamicamente carregado. 3. Registar os passos para clicar no botão "Start", aguarde a aparição do texto "Hello World", e verificar o texto. ```markdown # Caja de Testes: Aguardar Elemento Dinamicamente Carregado **Pré-requisito: ** Iniciar o gravador do Selenium Ide. **Passos: ** 1. Abrir o site: https://demoqa.com/dynamic-loading-example/ 2. Clicar no botão "Start" 3. Aguardar Elemento Visível: #hello 4. Verificar Texto: Hello World **Resultado: ** Se o elemento não aparecer num determinado período, a caja de testes falhará. ``` ### Reutilização de Cajas de Teste As cajas de teste frequentemente incluem passos redundantes, como se logar ou criar uma conta. O Selenium Ide nos permite rodar uma caja de teste por outra, tornando mais fácil evitar recriar esses passos comuns para cada caja de teste. ```markdown # Exemplo: Caja de Teste Reutilizável **Pré-requisito: ** Criar um novo projeto denominado "Projeto de Login. " **Passos: ** 1. Criar uma nova caja de teste: "Teste de Login" 2. Determinar o URL da página Login (p. ex. , um site de demonstração com funcionalidades de login). 3. Registar os passos de Login. 4. Extrair e salvar o scripts reutilizável. 5. Chamar o scripts reutilizável em outras cajas de teste como necessário. ``` # Selenium IDE: Utilização de Variáveis e Depuração Este guia demonstra como utilizar variáveis e depuração no Selenium IDE. ## Utilização de Variáveis Neste exemplo, vamos utilizar variáveis para um caso de teste de login. 1. Em vez de fornecer um valor fixo, utilize uma variável: - Substitua o valor de usuário fixo por `%usuário%` - Substitua o valor de senha fixo por `%senha%` ```markdown abre https://exemplo.com/login # Abre a página de login escreve %usuário% no campo de usuário # Insere o usuário escreve %senha% no campo de senha # Insere a senha clica Login # Clica no botão de login ``` 2. Defina as variáveis em algum lugar else: - Dependendo da sua configuração de teste, você pode definir variáveis em um Setup de Teste ou Desmontagem de Teste, em um caso de teste, ou no editor antes dos casos de teste. 3. Atribua valores às variáveis: - Utilize o comando `store` para armazenar os valores reais e atribuir a eles as variáveis. ```markdown armazena user1 em usuário # Atribui valor à variável usuário armazena pwd1 em senha # Atribui valor à variável senha ``` 4. Execute o caso de teste de login: - Chame a função do caso de teste de login, e os valores passados nas variáveis serão utilizados para o login. ```markdown executa teste de login # Executa o teste de login com as variáveis armazenadas ``` Para obter mais informações sobre a utilização de variáveis de usuário, consulte [Guia de Referência do Selenium IDE - Variáveis de Usuário](https://www.seleniumhq.org/docs/05_selenium_ide.html#user-variables). ## Depuração Esta seção explica como depurar casos de teste do Selenium IDE utilizando execução de passos, pontos de interrupção e desabilitando pontos de interrupção. ### Execução de Passos A execução de passos permite controlar a execução de passos individuais em seu caso de teste. 1. Execute todos os passos um-a-um: - Clique em qualquer lugar no editor de script para executar o próximo passo, e ele parará imediatamente após o passo ser concluído. 2. Utilize a opção "Executar o Comando Atual": - Clique no ícone para executar o comando atual e parar imediatamente depois. Para obter mais informações, consulte a [Guia de Depuração do Selenium IDE](https://www.seleniumhq.org/docs/05_selenium_ide.html#debugging). ### Pontos de Interrupção Os pontos de interrupção podem ser adicionados para parar a execução de seu caso de teste em pontos específicos. 1. Adicione um ponto de interrupção: - Clique em qualquer lugar na linha para adicionar um ponto de interrupção. 2. Execute o teste e observe a execução: - Enquanto o teste é executado, ele parará no ponto de interrupção adicionado, permitindo que você inspeione o estado atual. Para obter mais informações, consulte a [Guia de Depuração do Selenium IDE - Adicionando Pontos de Interrupção](https://www.seleniumhq.org/docs/05_selenium # Técnicas de Depuração em ID para Teste ## Usando a Opção 'Executar até este ponto' Esta seção demonstra o uso da opção 'Executar até este ponto' no ID. 1. **Requisitos pré-requisitos: ** - Já temos parado nas marcas de pontos. - Isto é apenas uma demonstração das seguintes etapas: adição, remoção e desabilitação de marcas de pontos. 2. **Passo a passo: ** - Para avançar a partir das marcas de pontos, utilize a opção 'Executar até este ponto'. - Feche a janela atual. - Por exemplo, vamos dizer que queremos adicionar uma nova marca de ponto. - Clique com o botão direito no comando específico e escolha 'Executar até este ponto apenas'. - Após a seleção, o script executará até o ponto especificado e parará. - Verifique se o script está parado no depurador. 3. **Depuração manual com o Comando 'Depurador'** - Outra forma de atingir isso é adicionando programaticamente um depurador. - No mesmo lugar, digamos após ter introduzido a palavra-passe, pode inserir o comando `debugger; `. - Quando os casos de teste forem executados neste ponto, o script entrará numa moda de depuração e parará. 4. **importante: ** - O comando depurador pode ser usado da mesma forma que as marcas de pontos. - O comando depurador pode ser usado para testar enquanto as marcas de pontos são adicionadas no ficheiro ID. ## Pausar ao Ocorrer uma Exceção Esta seção explica a funcionalidade 'Pausar ao Ocorrer uma Exceção' no ID. 1. **Remover o Comando Depurador: ** - Remova o comando depurador se não quiser o depurador. 2. **Pausar ao Ocorrer uma Exceção: ** - Esta funcionalidade é útil quando uma exceção ocorrer durante a execução do script. - Quando uma exceção for encontrada, o script parará nesse ponto e entrará numa moda de depuração. - Isto é particularmente útil quando o seu script completo teria parado devido a um erro, mas com 'Pausar ao Ocorrer uma Exceção', o seu script parará no ponto de falha. ## Declarações de Controle de Fluxo Esta seção descreve as declarações de controle de fluxo disponíveis no novo IDE. - Existem dois tipos de declarações de controle de fluxo: **Declarações condicionais** e **Laços de repetição**. ### Declarações Condicionais - Declarações condicionais disponíveis: if, if-else, if aninhados, else-if e end. ### Laços de Repetição - Declarações de laço disponíveis: Laço enquanto, Laço Do Repetir e Laço Para Cada. ## Um Script de Teste de Amostra Suponha que temos um Calculador de Calorias site, iremos: - Ir para o site, - Selecionar o género, - Escolher o nível de actividade, - e clicar no botão de calcular. Para o caso de uso demonstrativo, vamos supor que o género tem de ser armazenado numa variável, diga `gender`. Se o género é masculino, clique no botão de rádio masculino e selecione ativo a partir do deslizador selecção de atividade. Se o género é feminino, clique no botão de rádio feminino e escolha bastante ativo, exercícios intensos a partir do deslizador de seleção de atividade. --- URLs preservadas: - [Calculadora URL de Website] --- **Importante**: - Verifique e corrajais falhas antes de prosseguir com as cotas de teste. # Selenium IDE Script ## Criando uma variável para armazenar o gênero ```javascript var gender = 'male'; // Variável padrão é 'male' ``` ## Utilizando um if statement ```javascript if (gender === 'female') { // Se o gênero for 'female', então // Selecionar radio button femeen // Selecionar opção desejada no dropdown de atividade: 'muito ativo' } else { // Se nenhum outro caso é verdade, selecione a opção desejada no dropdown de atividade: 'ativo' } ``` ## Execução do script de teste ```bash execute the current test ``` ### Exemplos de loops em Selenium IDE #### Laço while ```javascript // Estabelecendo um contador let counter = 1; // Enquanto contador < 5 while (counter < 5) { // Executando o comando desejado } ``` #### Laço do ```javascript // Estabelecendo um contador let counter = 0; // Iniciando o comando do { // Executando o comando desejado counter++; } while (counter < 50); ``` #### Laço timeSlots ```javascript // Incrementando um contador timeSlots=3; // Executando um comando 3 vezes ``` ## Selenium IDE Side Runner Selenium IDE Side Runner é uma ferramenta de linha de comando que permite aos usuários executar testes de Selenium IDE em diferentes navegadores e executar testes paralelamente. Além disso, fornece uma maneira de usar o grid setup para executar testes em máquinas remotas. ### Configuração de instalação do Selenium IDE Side Runner Para trabalhar com Selenium IDE Side Runner, é necessário alguns pré-requisitos de instalação: 1. Servidor Node. js 2. Instalação do Selenium IDE Side Runner # Instalando Node. js e Selenium Side Runner em Sistemas Operativos Diferentes ## Instalador para Windows Se você trabalha em um computador com Windows, tem duas opções disponíveis: 1. Baixar o instalador MSI 2. Baixar a versão zip e descompactá-la em qualquer pasta do seu sistema Após baixar o pacote adequado (por exemplo, 64-bit), veja a estrutura de pastas: ``` node-vX. X. X-win32-x64 ├── node-vX. X. X-win32-x64. msi ├── node_modules │ └── . . . ├── npm ├── npm-debug. log └── . . . ``` Neste exemplo, o `npm` é a ferramenta que utilizaríamos para instalar os pacotes necessários no servidor Node. js. Para verificar se a instalação foi bem-sucedida, abra uma janela doprompt de comando e digite: ``` npm -v ``` Tem de ver a versão do Node. js que foi instalada (por exemplo, 6. 9). Agora, vejamos como criarmos a instalação da Biblioteca do Selenium Side Runner usando o npm: ``` npm install selenium-webdriver ``` ## Instalador para macOS Para MacOS, baixe a versão pkg e siga as instruções de instalação: ``` # Verificar a instalação: selenium-webdriver -version ``` ## Instaladores para Linux (Não coberto neste exemplo) A instalação em sistemas Linux pode variar. Consulte o site do Node. js e do Selenium para instruções de instalação apropriadas. ## Verificando a Instalação do Selenium Side Runner Após a instalação, pode verificar a instalação browseando para o diretório `node_modules` e verificar se o pacote `selenium-webdriver` está presente: ``` ls -l node_modules/selenium-webdriver ``` Se a instalação foi bem-sucedida, deve ver o pacote Selenium WebDriver disponível. Para mais informações sobre o Selenium Webdriver, veja o [site oficial do Selenium](http://www.seleniumhq.org/download/). Eis aqui! Agora você está pronto para escrever e executar testes automatizados com Node. js e o Selenium Side Runner. Boa sorte! 😊 😊 # Selenium Tutorial para Iniciantes Selenium WebDriver é uma ferramenta popular de automação de testes. Neste tutorial, você aprenderá a trabalhar com ele. ## Configuração básica de Selenium O primeiro passo é criar um projeto novo e instalar uma versão adequada de Selenium WebDriver conforme sua máquina ou IDE utilizada. Consultar esta [guia de instalação](link_to_installation_guide). ### Windows e macOS Instale o WebDriver através dos links a seguir: ``` windows_install_link mac_install_link ``` ### WebDriver Gerenciador (W3C) Além da instalação do WebDriver, você também precisa do Gerenciador do WebDriver para executar testes através da linha de comando (CLI) ou de ferramentas externas (por exemplo, Jenkins). Baixe o driver Gerenciador no link abaixo: ``` webdriver_manager_download_link ``` ## Ferramentas WebDriver Há uma variedade de ferramentas WebDriver disponíveis para seu uso. Um dos exemplos mais populares é o IntelliJ, mas você pode utilizar qualquer um dos seguintes: - Eclipse - NetBeans - JDeveloper - etc ## Tópicos de apoio Para ter um bom aprendizado no uso de Selenium WebDriver, os seguintes tópicos serão cobertos: 1. Primeiros passos 2. Controle de fluxo em testes (for, if, while e etc. ) 3. Definição e manipulação de variáveis de teste 4. Desafios relacionados ao DOM 5. Uso do `Javascript` em testes 6. Encontro dos elementos visuais usando `FindBy` ou `By. id`, `By. cssSelector`, etc. 7. Tratamento de `Exceptions` e `errors` 8. Configuração de fontes e variáveis globais para o projeto ## Teste paralelo Este tutorial também abordará a utilização da ferramenta Selenium IDE para executar testes automatizados em paralelo. Após configurar o comando de execução e marcar todos os testes desejados como "para execução paralela", você poderá lançar todos eles simultaneamente, resultando em uma diminuição nos tempos de execução dos testes. ```sh # execute-parallel ``` ## Configuração dos navegadores Além dos navegadores padrão, pode-se ajustar qualquer navegador padrão configurado localmente para os testes no seu projeto. Utilize a seguinte estrutura para carregar configurações padrão nos navegadores: ``` src |- main |- java |- [nomeDoPacote] |- webdriver |- chrome. java |- firefox. java |- safari. java ``` ```sh # Carregar padrão webdriver -Dwebdriver. chrome. driver=caminho/local/para/chromedriver ``` ## Limitados Por causa da natureza do Selenium WebDriver, há determinados limites em relação à sua usabilidade em determinados testes. Consulte aqui [suas limitações](limits_link) e aprender como lidar com eles. ``` # Simulando Múltiplas Cargas em Sua Aplicação – A necessidade da automação Automatizar os processos de teste da sua aplicação web pode trazer inúmeros benefícios. Aqui estão algumas razões por que: 1. **Execução Rápida**: A automação permite a execução de testes mais rápidos, comparados ao teste manual. 2. **Taxa de Erro Reduzida**: Os testes automatizados são menos susceptíveis de erros humanos, garantindo resultados mais precisos e fiaveis. 3. **Testes Frequentes**: A automatização facilita a execução de casos de teste quantas vezes for necessário, garantindo um teste mais rigoroso da sua aplicação. Existem várias ferramentas disponíveis para automatização, com a Selenium sendo uma das mais populares e amplamente utilizadas. A Selenium foi introduzida por Jason Huggins em 2004, como um programa JavaScript que controlava automaticamente as ações do navegador para permitir o teste frequente da aplicação web. ## O Que é a Selenium? A Selenium é uma ferramenta de automatização de código aberto utilizada para automatizar o teste de aplicações web em vários navegadores, incluindo: - IE - Chrome - Firefox - Safari - Edge - Opera - Navegador headless A Selenium é independentente de plataforma, o que significa que pode rodar em qualquer plataforma, e é gratuita de custo, tornando-se a opção preferida para muitos testers. É um conjunto de ferramentas e bibliotecas que facilitam a automatização de aplicações web, e não é uma ferramenta única. ## Componentes da Selenium A Selenium consiste em vários componentes, os quais serão discutidos em detalhes mais adiante. Os principais componentes da Selenium são: 1. **Selenium Integrated Development Environment (IDE)**: É o instrumento mais simples no conjunto de ferramentas da Selenium, oferecendo uma funcionalidade de registro e reprodução, tornando tudo isso fácil e intuitivo. No entanto, é primarily usado para prototipação e não para criar automação real para projetos reais devido aos seus próprios limites. 2. **Selenium Remote Control (RC)**: Este componente é utilizado para escrever testes de aplicações web em diferentes linguagens de programação, como Java, C, Perl, Python, e PHP. O server em si é escrito em Java e interage com o navegador utilizando o servidor RC. 3. **Selenium WebDriver**: Este componente substituíu o selenium Remote Control na Selenium 2. 0 e foi depreciado na Selenium 3. 0. Ele fornece mais funcionalidades e melhor suporte para aplicações web modernas. 4. **Selenium Grid**: Este componente permite executar os seus testes em diferentes plataformas e navegadores, fornecendo suporte para a execução em paralelo de testes. ## Selenium IDE O Selenium IDE é o instrumento mais simples no conjunto de ferramentas da Selenium. É um ambiente de desenvolvimento integrado com uma funcionalidade de registo e reprodução. Este instrumento é útil para prototipação, mas tem limitações devido a ser apenas um instrumento de registo e reprodução. O Selenium IDE está disponível como um plugin para Firefox e como uma extensão para Chrome, tornando-se independente de plataforma. Com o Selenium IDE, pode registrar os seus scripts de teste, controlar a velocidade de execução e executar vários testes. Os scripts registrados de teste consistem de comandos autodescricivos, como abrir, clicar, tipar, afirmar e fechar. Uma janela de registro mostra o status de execução para cada passo, permitindo identificar eventuais falhas. Para mais informação detalhada sobre como utilizar o Selenium IDE, consulte o nosso vídeo sobre o Selenium IDE no [simplylearn. com](http://simplylearn.com). # Mesma Política de Origem e Selenium A Mesma Política de Origem (MOP) é uma medida de segurança crítica que impede seu JavaScript de acessar elementos ou de interagir com scripts de um domínio diferente do que é lançado. Por exemplo, cada página dentro do domínio Google. com, como pesquisa, email ou Google Drive, é acessível, mas nada que estive fora deste domínio, como Yahoo ou Amazon, é possível devido razões de segurança. Para superar isso, Paul Hammond criou o Servidor de Controle Remoto (CR) do Selenium, também conhecido como um servidor remoto, que atua como um intermediário para enganar o navegador a acreditar que seu Selenium Core e a sua aplicação web sob teste estão no mesmo domínio. Isso elimina a MOP, e isso foi chamado de Controle Remoto do Selenium (versão 1 do Selenium). ## Arquitetura Simples do Selenium CR 1. **Script**: Primeiro, você precisa escrever seus scripts usando qualquer idioma suportado, como PHP, Java, Python, e Ruby. 2. **Servidor CR**: Antes de iniciar os testes, você precisa instalar o Servidor CR. Este Servidor CR é uma aplicação separada e, uma vez instalado, é responsável por receber os comandos Selenium. 3. **Interação de navegador**: Estes comandos Selenium são interpretados e em execução nos seus navegadores. Resultados são enviados de volta para seus scripts de teste, e esta interação de navegador ocorre apenas através do Servidor CR. A comunicação ocorre usando solicitações HTTP simples GET e POST. ## Desvantagens do Selenium CR 1. **Arquitetura Complexa**: A arquitetura do CR beatingua a complexa por conta do intermediário Servidor CR, que atua como um intermediário entre os seus comandos Selenium e o seu navegador. 2. **Execução Lenta**: A execução de comandos demora muito tempo, porque cada comando precisa fazer uma viagem inteira de seu script de teste para o Servidor CR, o Core e o Navegador, o que faz a execução geral de testes muito lenta. Para superar estas desvantagens, o WebDriver foi introduzido. Os WebDrivers do Selenium foram desenvolvidos por Styan Stewart em 2006. É um framework de teste multiléscula e uma interface de programação para criar e executar casos de teste. ## Vantagens do Selenium WebDriver 1. **Arquitetura Mais Simples**: O WebDriver elimina a necessidade de um intermediário Servidor CR e tem uma interação direta com a aplicação do navegador, o que faz a arquitetura mais simples. 2. **Execução Mais Rápida**: Com uma comunicação direta, a velocidade da execução de testes é muito maior que o CR. 3. **Múltiplas Línguas e Frameworks**: O WebDriver oferece suporte a várias línguas e tem integração com vários frameworks. ## Como Funciona o Selenium WebDriver 1. **Bibliotecas de cliente**: O Selenium oferece suporte a várias línguas, e você está livre para usar qualquer determinada língua para criar seu script de automação. Estas bibliotecas estão disponíveis em seleniumhq. org. 2. **Drivers do navegador**: Para cada navegador, existem drivers específicos dele. Você pode baixar esses arquivos de driver de seleniumhq. org. Estes drivers interagem com o navegador real sem revelar a lógica interna da funcionalidade do navegador. 3. **Execução de um script de teste**: Um script de teste é executado enviando uma solicitação HTTP para o driver de navegador, que então é executado diretamente no navegador. O status de execução é então enviado de volta para seu script de teste. Aqui está um exemplo de um script de teste usando o WebDriver: ```java // Lance o navegador, navegue para amazon. com, busque o título da página e feche o navegador WebDriver driver = new FirefoxDriver(); driver. get("https://www.amazon.com"); String title = driver. getTitle(); System. out. println("Título da Página: " + title); driver. quit(); ``` Neste exemplo, o `FirefoxDriver` é usado para iniciar o navegador Firefox. O `getTitle()` método é usado para pesquisar o título da página, e o `quit()` método é usado para fechar o navegador. Com o WebDriver, você pode executar seus scripts de teste em vários navegadores e sistemas operacionais simultaneamente, reduzindo o tempo gasto na execução. Para isso, o Selenium oferece o Grid, que é projetado para distribuir comandos para máquinas diferentes em um ambiente de execução em tempo real. Isto permite a execução paralela de testes em vários navegadores e sistemas operacionais, e pode ser integrado com ferramentas de relatórios para gerar um relatório consolidado após os testes terem sido executados em várias máquinas. # Selenium Grid: Um Guia Compreensivo O Selenium Grid permite a execução de testes em paralelo em vários nós, através de uma configuração na máquina-mestre. É possível configurar combinações específicas de teste, como os exemplos abaixo: - Executar testes de fumo em todos os nós - Executar testes de componente específicos em sistemas operacionais e navegadores específicos (por exemplo, Windows 10 com o navegador Edge) - Executar todos os testes da suíte de regressão apenas em máquinas macOS Este tutorial vai explicar como configurar o Selenium Grid e executar testes em uma rede. ## Versões do Selenium - A versão 1 do Selenium tinha o IDE e Grid. O IDE estava de forma depreciada e o script de driver estava sendo criado. - A versão 2 trouxe uma versão mais antiga do script de driver e o IDE ainda existia até a versão 3. 0, após a qual foi totalmente removido e o script de driver ficou por conta inteira. - À princípio, existe uma versão 4. x no caminho, com novas funcionalidades e melhorias. Alguns das funcionalidades esperadas incluem as normas W3C da especificação do protocolo WebDriver e melhorias no grid. ## Vantagens do Selenium - **Velocidade e precisão**: da natureza automatica, os testes executam mais rapidamente do que a execução manual e, com o Grid, é possível executar um volume grande de testes em um breve período de tempo. - **Grátis**: o Selenium é um pacote de código aberto disponível gratuitamente e sem custo. - **Flexibilidade**: o Selenium suporta uma variedade de linguagens de programação. - **Suporte a vários navegadores e sistemas operacionais**: assim como inúmeras plataformas de navegação e sistemas operacionais, o Selenium também suporta a Execução de testes em navegadores headless. ## Limitações - **Suporte limitado a testes de aplicativos móveis e desktop**: o Selenium não pode executar testes automatizados em aplicativos móveis ou de desktop. No entanto, é possível integrar ferramentas de teste de aplicativos móveis suportadas por Selenium. - **Relatórios limitados**: o Selenium fornece suporte básico à criação de relatórios, mas são necessários recursos adicionais para criar relatórios mais detalhados. - **Documentação limitada**: embora seja um projeto de código-fonte aberto, o Selenium não oferece suporte técnico direto. Entretanto, existem muitos recursos de documentação e fóruns disponíveis na Internet para consulta. ## Instalação do Selenium no sistema Windows A instalação do Selenium no sistema Windows é um processo em três etapas: 1. **Instalação do Java**: primeiramente, é necessário ter o Java instalado no sistema para poder instalar o Selenium. Neste tutorial, você aprenderá a instalar o Java e o WebDriver para o Chrome. 2. **Instalação do Eclipse IDE**: após o Java, instalará-se o IDE do Eclipse. Este tutorial viabilizará a instalação do Eclipse para desenvolvedores Java. 3. **Instalação do Selenium**: finalmente, você estará instalando o Selenium para Java. Tudo isso será feito com a versão Java 8 e o Eclipse com a versão 4. 10. # Instalação do Eclipse com Selenium Este guia ensina a instalar e usar o Eclipse com o Selenium. ## Instalação do Eclipse O primeiro passo é instalar o Eclipse. Clique em `Install` para iniciar a instalação, que pode levar um tempo. ## Criando um workspace Após a instalação do Eclipse, abra-o e selecione um workspace. Um workspace é uma pasta que serve como a contêiner principal para todos os arquivos de projeto que serão criados. ``` O workspace dirá onde todos os arquivos Java ou quaisquer outros artefatos criados no Eclipse serão salvos. Você pode escolher qualquer localização do sistema. ``` Clique em "Selecionar pasta" e crie uma pasta chamada "workspace". ## Criando um novo projeto Depois de selecionar o workspace, crie um novo projeto clicando em `File > New > Java Project`. Deixe um nome para o projeto e selecione a JDK 1. 8 como a JRE para usar. ## Instalando o Selenium Para instalar o Selenium, vá para o site oficial [seleniumhq. org](https://www.selenium.dev/) e baixe as instalações necessárias. Neste exemplo, será necessário: 1. Selenium Client e WebDriver Bibliotecas para Java 2. Gecko Driver (Se estiver usando o Firefox) 3. Chrome Driver (Se estiver usando o Chrome) Depois de baixar o arquivo zip, descompacte-o e copie os arquivos para a pasta "drivers" no seu workspace utilizando as seguintes etapas: 1. Adicione as bibliotecas do Selenium ao projeto no Eclipse 1. Abra o projeto no Eclipse e clique com o botão direito no projeto 2. Clique em `Build Path > Configure Build Path` 3. Clique em `Libraries > Add External Jars` 4. Selecione todos os arquivos `. jar` de selenium na pasta do arquivo descompactado 5. Clique em `Add` e feche a guia "Configure Build Path" 2. Adicione o driver adequado aos projetos 1. Se estiver usando o Firefox: inclua o arquivo `geckodriver. exe` na pasta "drivers", que pode ser encontrado na pasta do lançamento do Selenium. 2. Se estiver usando o Chrome: inclua o executável `chromedriver. exe` na pasta "drivers" Agora você está pronto para começar a escrever scripts Selenium! ## Testando o Selenium com um script Para demonstrar código em execução em um editor Markdown não é possível executar scripts Selenium no momento, mas você pode ver o exemplo funcionando em um ambiente de desenvolvimento. ## Referências 1. [Instalando o SeleniumWebDriver para Java em um projeto Maven](https://www.selenium.dev/getting-started-with-webdriver/) 2. [Instalando o ChromeDriver](https://sites.google.com/a/chromium.org/chromedriver/getting-started) 3. [Instalando o GeckoDriver](https://github.com/mozilla/geckodriver/releases) Título: Instalação do Selenium em Mac ====================================== Nesta sessão, vamos examinar como instalar o Selenium em suas máquinas Mac. A instalação do Selenium em Mac é um processo de três passos: 1. Instalação do Java 2. Instalação do Eclipse 3. Instalação do Selenium ### Instalação do Java Para instalarmos o Java, vamos abrir nossos navegadores e simplesmente procurar por "Java 8 download". Quando estivermos no site Oracle para download, veremos algo chamado de "Java Software Development Kit (JDK) 8". Este é a versão que trabalharemos com. Para o download, você precisará ter uma conta Oracle. Se você não tiver uma conta Oracle, por favor, vá se cadastrar para você mesmo. Vamos entrar e baixar o nosso pacote. Vou baixar o `jdk-8u211-macosx-x64. dmg` pacote. Para isso, preciso clicar em "Accept License Agreement". Como estamos trabalhando em Mac, este é o pacote que eu vou baixar. Clique aqui e agora o download deve começar. No entanto, não esperaremos a conclusão do download, pois eu já baixei o pacote e o maintaini em um dos meus arquivos. Vou mostrar-lhe onde está. Criei um arquivo chamado de `installers` e todos os programas que necessitaremos hoje para trabalhar com o Selenium é o que eu baixei e mantive aqui. Vamos ir passo a passo para que você compreenda o que cada um dos pacotes são. Como vemos aqui, eu tenho o `jdk-8u211-macosx-x64. jars` que eu já baixei. Vamos proceder com a instalação do JDK. Você tem o . dmg arquivo aqui. Você apenas clica nessa e duplica-o. Agora dou dois cliques no pacote e então dito "Continue" e "Install". Será pedido para que eu publique minha senha. Tiví-la dado e dito "Instalar o software". Provavelmente levará apenas alguns minutos para a instalação ser concluída. Quando a instalação estiver completa, vou fechar esta janela. Agora vou ir para a minha janela do terminal. Vou abrir o terminal e aqui vou dizer `java -version`. Aqui temos o Java 1. 8 instalado em nosso sistema. Agora existem algumas outras coisas que você precisará fazer além da instalação do seu JDK. Você também precisará configurar algumas variáveis do sistema em Mac. Em Mac, você configura as variáveis do sistema ou as variáveis de ambiente em seu `~/. bash_profile` (cada usuário tem um arquivo escondido no diretório principal chamado `. bash_profile`; é usado para exportar variáveis em sua shell). Vamos ver como isso é feito. Vou utilizar um editor chamado `vi`. Depois vou abrir meu `~/. bash_profile`. O que vou fazer é adicionar o `java home path`. Agora eu já tenho outros caminhos aqui escritos porque eu trabalho com várias ferramentas software em esta máquina. Agora vou ir até o final deste arquivo e vou dizer: ```bash export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1. 8. 0_211. jdk/Contents/Home ``` Definiei o JAVA_HOME como o caminho onde o Java foi instalado em meu sistema. Agora, salve-o o arquivo (escape para sair do modo *insert*: `: wq`) e saia-o. Para que o `. bash_profile` seja ativado, você precisará sair desse terminal. Feche esta janela do terminal e eu vou fazer uma nova janela. Aqui eu novamente digo `java -version`: ```bash java -version java version "1. 8. 0_211" Java(TM) SE Runtime Environment (build 1. 8. 0_211-b12) Java HotSpot(TM) 64-Bit Server VM (build 25. 211-b12, mixed mode) ``` Tudo parece estar funcionando corretamente. Isso completa nossa instalação de Java. Agora seu sistema está pronto e você tem o Java a funcionando. ### Instalação do Eclipse Agora, a próxima etapa é ir adiante e instalar o Eclipse. A mesma coisa, buscando por "Eclipse Download" em meu navegador, vamos para [eclipse. org](http://eclipse.org). Quando você fizer essa instalação, verá a versão mais recente por aqui. Minha recomendação é que em vez de trabalhar com a versão mais recente disponível, eu recomendo que você trabalhe com a última versão estável, e justamente é isso que você irá fazer hoje. Para ir para as versões anteriores, eu preciso apenas ir aqui na página do download e clicar nesse botão. Quando você clicar nesse link, clicará nesta página. Se você rolar para cima, verá algo chamado de "More Downloads". Aqui você verá todos os builds de Eclipse disponíveis, todas as suas versões anteriores. Hoje, vou trabalhar com a versão 4. 10, vou avançar e clicar nessa `4. 10` (a versão foi lançada em dezembro de 2018). Quando você olhar para esse intallador, tem vários pacotes disponíveis aqui de acordo com suas necessidades. Escolha o pacote com o qual você quer trabalhar. Hoje, como estou vindo a usar a versão IDE de Java para Desenvolvedores do Eclipse, vou avançar e clicar nesta "downloadable" e depois clicar emque é Descender, que descendera este pacote para mim. Tive que já baixar este arquivo e o mantei: ```bash eclipse-jee-2019-03-R-macosx_cocoa_x86_64 ``` Instalar o Eclipse, coisas simples como o que fizemos para o JDK. Estou a fazer um duplo click nessa e instalando. Vou mostrar como o Eclipse se instala. Agora pouco movimento do mouse e criei uma pasta chamada `Applications` não para lá. Agora, o Eclipse está pronto. Simplesmente clique, vou abrir. Tá aberto. Está carregando os recursos do Eclipse. ### Instalação do Selenium Agora com o Java e o Eclipse instalados, vamos continuar com a instalação do Selenium. Novamente, vou abrir meu navegador. Isto vez, vou ir para [seleniumhq. org](http://seleniumhq.org), o que vai ser uma bíblia para você se estiver trabalhando com o Selenium. Neste site, eu vou ir para "downloads". Aí queremos descer os dois coisas para poderemos trabalhar com o Selenium: 1. Selenium Standalone Server 2. Selenium Client e WebDriver Language Bindings. Vamos descer o cliente e porque estamos a trabalhar com a API de cliente Java com o Selenium, vou baixar os arquivos `jar` (Java Archive) para o Selenium Standalone Server e o Selenium WebDriver Client Java. Para o Selenium Standalone Server, preciso clicar nesta janela. Será baixada a pilha para mim. Vou baixar e mostrarei para você. Para o Selenium Client e WebDriver Language Bindings Java, já baixei o arquivo `selenium-java-3. 141. 59. jar`. Agora temos todos os arquivos necessários, vamos começar com nossos testes com Selenium. Vamos escrever um teste simples usando `JUnit` e `TestNG`. No Eclipse, vamos criar um novo projeto Java e chamar-lhe algo como "SeleniumDemo". Agora, vamos adicionar nossa variável de ambiente JAVA_HOME no Eclipse: 1. Clique com o botão direito na pasta do projeto e vá para `Properties`. 2. Na janela de propriedades, clique em `Java Build Path`. 3. Clique em `Libraries`. 4. Clique em `Add External Class Folder`, ele irá pedir você a selecionar a pasta do JavaSDK. Seu caminho é o `/Library/Java/JavaVirtualMachines/jdk1. 8. 0_211. jdk/Contents/Home`. 5. Agora, sua JDK foi adicionada como uma extensão Jar. 6. Clique no `Order and Export` e certifique-se que a JDK está selecionada e também há um checkbox para "Export". 7. Clique em "OK" para salvar. Agora vamos adicionar nossas dependências do Selenium: 1. Clique novamente com o botão direito na pasta do projeto e vá para `Build Path` > `Configure Build Path`. 2. Na janela de Libraries, clique em `Add External Jars`. 3. Selecione os arquivos `selenium-java-3. 141. 59. jar` e `selenium-server-standalone-3. 141. 59. jar` da pasta de instalação e clique em `Open`. 4. Clique em `OK` para salvar. Agora podemos começar a escrever nossos testes com o Selenium. vamos criar uma nova classe Java chamada `GoogleSearchTest` e copie a seguinte código: ```java import org. junit. Test; import org. openqa. selenium. By; import org. openqa. selenium. WebDriver; import org. openqa. selenium. WebElement; import org. openqa. selenium. chrome. ChromeDriver; import static org. junit. Assert. assertTrue; public class GoogleSearchTest { private static WebDriver driver; @Test public void searchForSelenium() { System. setProperty("webdriver. chrome. driver", "/path/to/your/chromedriver. exe"); driver = new ChromeDriver(); driver. get("https://www.google.com"); WebElement searchBox = driver. findElement(By. name("q")); searchBox. sendKeys("selenium"); WebElement searchButton = driver. findElement(By. name("btnK")); searchButton. click(); WebElement result = driver. findElement(By. linkText("Selenium - Web Browser Automation")); assertTrue(result. isDisplayed()); driver. quit(); } } ``` Para `chromedriver. exe`, você precisará baixar e definir o caminho adequado. Agora podemos rodar nossos testes: 1. Clique com o botão direito na classe `GoogleSearchTest` e selecione `Run As` > `JUnit Test`. 2. Você verá o teste executado, e deverá passar corretamente. Assim é que tivemos sucesso na instalação do Selenium em nossa máquina Mac e geramos um teste simples utilizando o WebDriver do Selenium e JUnit. Agora você está livre para utilizar este setup para testes mais complexos com o Selenium. 🙂 # Tutorial: Utilizando Selenium com Java É necessário ter o cliente de Selenium Java baixado. Se você estiver analisando c#, C#, Ruby, ou Python, terá os respectivos pacotes que poderá baixar agora, já que iremos estar trabalhando com Java aqui. Clique nesses links para baixar o cliente de Selenium (1) e (2). Após baixar, verifique os downloadáveis no seu computador. Encontre o arquivo "selenium-java-x. x. x. zip", onde x. x. x é a versão do Selenium que você baixou. Abra o arquivo encontrando as JARs do Selenium. Para utilizar o Selenium em um IDE como o Eclipse, seguindo as etapas abaixo: 1. Abra o Eclipse 2. Clique com o botão direito do mouse em seu projeto no *Package Explorer* 3. Selecione **Propriedades** e então **Configure Build Path** 4. Clique em **Libraries** e depois em **Adicionar Arquivos Externos** 5. Selecione todas as JARs que estão dentro do YAML-cat. bat do Selenium que você baixou anteriormente 6. Clique em **Aplicar** e **Fechar** ## Importando JARs Verifique se todas as JARs adicionadas foram importadas corretamente. Para fazer isso, acesse a **Expansão da Lista de Referências** na aba **Típocubagem** e verifique se as seguintes JARs do Selenium estão listadas: - org. openqa. selenium-x. x. jar - org. openqa. selenium. firefox-x. x. jar Agora você está pronto para escrever seu script de teste WebDriver do Selenium: ```java import org. openqa. selenium. WebDriver; import org. openqa. selenium. firefox. FirefoxDriver; public class SeleniumFirstTest { public static void main(String[] args) { // Criar um objeto WebDriver WebDriver driver = new FirefoxDriver(); // Abrir o browser e navegar para o site amazon. com driver. get("https://www.amazon.com/"); } } ``` **Importante: ** Este método de importação mostrado aqui é apenas uma forma de importar as JARs no Eclipse. Dependendo da sua preferência, pode haver outras maneiras de fazer isso. # Selenium IDE - Uma Guia Compreensiva Este documento fornece uma visão detalhada do Selenium IDE, uma ferramenta de gravação e execução de tarefas de teste de aplicações web. [Leia mais sobre Selenium](https://www.selenium.dev/) ## O que é o Selenium IDE? O Selenium IDE foi desenvolvido em 2006 como uma ferramenta simples para a gravação e execução de tarefas de teste automatizado. Inicialmente, as ferramentas de gravação e execução foram populares devido à sua funcionalidade, pois permitiam que engenheiros de automação criassem automação de teste sem conhecimento de programação. O Selenium IDE estava disponível como uma extensão para Firefox, fazendo-o fácil de usar para uma instalação única. A ideia fornece uma interface simples para a criação de scripts de automação. Os usuários podem começar a registrar seus passos de testes, e os passos são grabados no script. Subsequentemente, estes scripts podem ser exportados como vários scripts como WebDriver, JUnit, Ruby, ou JavaScript, e então usados de acordo com a preferência do usuário. No entanto, é importante notar que a ferramenta de gravação e execução não oferece o poder de uma ferramenta de automação completa. Assim, o Selenium IDE é principalmente usado para propósitos prototipados ou demonstrações. Desde o Selenium WebDriver proporciona poderosas capacidades para a criação de scripts de teste robustos, o Selenium IDE é frequentemente considerado uma parte do conjunto de ferramentas Selenium. ## Vantagens do Selenium IDE 1. **Melhor funcionalidade de localizador: ** O Selenium IDE tem avançado significativamente em relação às técnicas de localização, fazendo com que os casos de teste sejam mais robustos. Localizadores são usados para localizar elementos da aplicação de teste subjacente. O Selenium IDE fornece vários localizadores para um mesmo elemento Web. Isso garante que os testes passarão mesmo se um localizador parar de funcionar devido ao alteração das atribuições do elemento Web. 2. **Execução em paralelo: ** A versão tradicional do Selenium IDE não oferecia a execução paralela, mas esta característica está disponível na versão nova. Exploraremos este recurso em mais detalhes mais tarde neste vídeo. 3. **Instruções de controle: ** O Selenium IDE suporta instruções de controle como `if`, `else`, `while`, `for`, e `switch` casos. Esteas instruções ajudam a criar cenários de automação de teste mais complexos. 4. **Aguardar carga de página: ** O Selenium IDE garante que as scripts esperem por as páginas carregarem antes de executar, o que é crucial para a prevenção de falhas devido aos scripts executando mais rápido que a aplicação de teste subjacente. 5. **Execução de código integrado: ** O Selenium IDE permite a execução de JavaScript dentro do script de teste para funcionalidade personalizada. 6. **Depurar e integração com pipeline CI/CD: ** O Selenium IDE inclui um depurador com execução por etapas e pontos de interrupção. O depurador também pode pausar em exceções, facilitando a manutenção e a depuração. Além disso, os scripts podem ser integrados em ambientes de ci/cd e executados a partir da linha de comando. ## Instalando o Selenium IDE Para instalar a extensão do Selenium IDE no Chrome: 1. Digite "selenium id para Chrome" na loja de extensions do Chrome. 2. Clique em "Add to Chrome. " 3. Após a adição da extensão, você verá o ícone do Selenium IDE no painel de ferramentas. Para Firefox, a extensão está já instalada se você está utilizando-o como o navegador para demonstrações neste vídeo. Para abrir o Selenium IDE, clique no ícone da extensão, o que abrirá uma nova janela. ## Usando o Selenium IDE A nova versão do Selenium IDE dá suporte tanto a Firefox quanto a Chrome, tornando-o compatível entre navegadores. você pode abrir um projeto existente, criar um novo ou iniciar a gravação de um caso de teste novo. Após o caso de teste ser criado, ele pode ser executado e gerenciado os resultados. O script irá reproduzir as etapas de automação que você realizou durante a etapa de gravação. Quando se trata de usar o Selenium IDE, é essencial entender os princípios da automação de testes e seguir boas práticas na escrita de testes robustos e manuteníveis. As vantagens de usar o Selenium IDE, como localizadores melhorados, execução em paralelo, instruções de controle, execução de código integrado, depurar e a integração com CI/CD tornam o Selenium IDE uma ferramenta indispensável para testes de aplicações web. # Gravação e Verificação de Script para Estabilidade e Taxa de Sucesso Este tutorial vai te guiar a usar uma interface de desenvolvimento integrado (ID) para gravar e monitorar scripts de teste. Esta interface inclui uma barra de menus, ferramentas, barra de endereços, editor de script de teste, painel de casos de teste, registro de teste e referência. ## Barra de Menus A barra de menus permite: - Editar o nome do projeto - Criar um novo projeto - Abrir um projeto existente - Salvar o projeto atual - Todas estas opções estão localizadas na barra de menus. ## Ferramentas A ferramenta contém vários componentes: 1. **Executar Todos os Testes**: Executa todos os testes de forma sequencial. 2. **Executar Teste Atual**: Executa o teste com o foco atual. 3. **Depurador**: Permite executive o script passo-a-passo. 4. **Gravar**: Inicia ou para o processo de gravação. 5. **Pausar Execução**: Pausa a execução do script. 6. **Desabilitar Pontos de Interrupção**: Permite desabilitar pontos de interrupção no script. ### Depurador A opção de depurador na ferramenta permite execução de passos individuais no script. Por exemplo: 1. Clique no botão 'Executar o Comando atual'. 2. Observe a execução do script passo por passo. ### Gravação Para gravar um script, clique no botão de 'Gravar', execute as ações desejadas e clique em 'Parar Gravação' quando terminado. ## Barra de Endereços A barra de endereços é onde você digita o URL a partir do qual deseja começar a gravar scripts de teste. ## Editor de Script de Teste O editor de script de teste é onde suas passos gravados e interações estão exibidos. ### Comandos Os comandos são as operações ou ações reais realizadas em elementos web. Exemplos de comandos incluem `abrir`, `digitar`, `enviar teclas` e `clicar`. ### Alvo O alvo é o elemento web no qual você deseja realizar a ação, e pode ser identificado utilizando várias técnicas de localização. ### Valor Valor é um campo opcional onde você pode enviar algum valor para seu elemento web. ### Comentário ou Descrição Aqui você pode mencionar alguma descrição ou comentário sobre a linha gravada. ## Painel de Casos de Teste O painel de casos de teste contém todos os casos de teste gravados. Permite: - Criar novos casos de teste - Organizar casos de teste em conjuntos de testes - Executar casos de teste - Visualizar o estado de execução de cada caso de teste ## Registro de Teste e Referência Os jornais de teste e referência são janelas importantes que registram a execução de cada comando durante o teste. A janela de referência também fornece informações detalhadas sobre cada comando, incluindo como usá-lo. ## Criação de um Novo Script de Teste 1. Crie um novo projeto. 2. Adicione um teste, e defina o seu propósito como automatização de um caso de uso específico. 3. Digite o URL, procure os itens desejados e execute ações no canal. 4. Grave as suas ações usando o ID. 5. Revise e edite as comandos gravados. 6. Execute o script para verificar sua funcionalidade. # Comandos de Selenium em Markdown Este documento fornece uma visão geral dos comandos de Selenium, com ênfase em comandos de ação, acessores e afirmações. ## Comandos de Ação Os comandos de ação são os que interagem diretamente com os elementos web da sua aplicação. Alguns exemplos de comandos de ação são: - `open`: Abre uma nova URL - `setWindowSize`: Define o tamanho da janela - `click`: Clica em um elemento web - `type`: Digita texto em um elemento web Podes encontrar a lista completa dos comandos de ação [aqui](#comandos-de-ação). ## Acessores Os acessores são os comandos de Selenium que analisam o estado da aplicação e armazenam os resultados em uma variável. Alguns exemplos de acessores são: - `storeTitle`: Armazena o título da página web atual - `storeText`: Armazena o atributo de texto de um elemento web - `storeValue`: Armazena o atributo de valor de um elemento web Podes encontrar a lista completa dos acessores [aqui](#acessores). ## Afirmações As afirmações são utilizadas para verificar o estado da aplicação. Por exemplo, pode usar afirmações para verificar se o título da página da web é o esperado. ## Usando o Comando Echo O comando `echo` não é utilizado em elementos web, mas é utilizado para exibir um mensagem no console. Aqui está um exemplo de como utilizar o comando `echo`: ``` echo Isso é o final da execução do script ``` Podes pular o script a partir de uma linha específica selecionando "Rodar a partir deste ponto" ao clicar com o botão direito na linha. ## Exemplo: Usando os Comandos de Armazenar Texto Aqui está um exemplo de utilização do comando `storeTitle` e do comando `echo` para armazenar e exibir o título da página da web: ``` storeTitle titulo echo $titulo ``` ## Comandos de Ação Os comandos de ação de Selenium podem ser classificados em três categorias de forma geral: 1. Comandos de Ação: Interagem diretamente com os elementos web da sua aplicação. 2. Acessores: Analisam o estado da aplicação e armazenam os resultados em uma variável. 3. Afirmações: Verificam o estado da aplicação. ### Comandos de Ação Aqui está uma lista dos comandos de ação, listados em ordem alfabética: - `addSelection` - `click` - `close` - `doubleClick` - `dragAndDrop` - `echo` - `executeScript` - `get` - `getLocation` - `getSize` - `getTagName` - `getTitle` - `getText` - `getWindowHandle` - `getWindowPosition` - `getWindowSize` - `getWindowUrl` - `getWebElement` - `goBack` - `goForward` - `goTo` - `pause` - `refresh` - `sendKeys` - `submit` - `takeScreenshot` - `quit` - `setAlertText` - `switchTo` - `switchToAlert` - `switchToFrame` - `switchToIframe` - `switchToWindow` ### Acessores Aqui está uma lista dos acessores, listados em ordem alfabética: - `storeTitle` - `storeText` - `storeValue` - `getAttribute` - `getCssValue` - `getDomAttribute` - `getLocation` - `getSize` - `getTagName` - `getText` - `getWindowHandle` - `getWindowPosition` - `getWindowSize` - `getWindowUrl` - `getWebElement` - `isDisplayed` - `isEnabled` - `isSelected` - `getAttribute` - `getCssValue` - `getDomAttribute` - `getLocation` - `getSize` - `getTagName` - `getText` - `getWindowHandle` - `getWindowPosition` - `getWindowSize` - `getWindowUrl` - `getWebElement` - `isDisplayed` - `isEnabled` - `isSelected` ### Exemplo: Usando o Comando de Armazenar Valor Aqui está um exemplo de utilização do comando `storeValue` para armazenar o valor de um elemento web: ``` storeValue valor do elemento valor echo $valor ``` # Acessador vs Aserções em Selenium IDE Neste tutorial, discutiremos o comando Acessador e Aserções no Selenium IDE. ## Comando Acessador O comando Acessador recupera o valor de um elemento específico numa página web. Ele nos permite interagir de forma programática com aplicações web. ### Aserção Dura Quando executarmos o comando Aserção, e se ele falhar, o teste termina imediatamente e marca o caso de teste como falhou. Por exemplo, se estivermos asertando o título de uma página e, se ele não corresponder ao resultado esperado, o teste falhará imediatamente, como logo que encontrar a falha, o resto do caso de teste não será executado, e o caso de teste será marcado como `falhou`. ### Aserção Mole (Verificar) Verificar é chamado de aserção mole, onde o Selenium IDE bloqueia esse particular aserção como falhada, mas irá continuar com os próximos passos no caso de teste, e depois ao final dele, o caso de teste será marcado como `falhou`. Neste caso, o teste continua com os próximos passos e depois conclui sua execução, e então marca o caso de teste como uma falha. ### Aguardar Aguardar é usado para aguardar uma certa condição ser verdadeira. Após isso, continua com os passos seguintes. Se a condição for falsa, por exemplo, se está a aguardar um elemento a aparecer numa página web e se esse elemento não aparecer, o teste falhará, mas prosseguirá e completará o teste executando os passos restantes e depois marcando o caso de teste completo como falhado. ## Demonstração ### Aserção Dura #### Exemplo - Aserção Título (Amazon) - assertTitleAmazon Neste exemplo, se o título da página não for "Amazon", o caso de teste falhará e parará. ### Aserção Mole (Verificar) Para demonstrar a Aserção Mole, usaremos um site de demonstração que carrega um elemento de forma dinâmica depois de um tempo. #### Exemplo - Aguardar Elemento Visível - waitForElementVisible - Alvo: hello volta - Timeout: 10000 (10 segundos) - Asertir Texto - assertText - Alvo: hello world Neste exemplo, estamos aguardando o elemento `hello volta` a aparecer, e quando ele aparecer, usamos `assertText` para verificar que o texto é realmente `hello world`. Se o elemento não for encontrado dentro do esperado para o tempo limite, o caso de teste falhará. ## Reprodutibilidade de Scripts de Teste Numerosos scripts de testes podem envolver o acesso a uma aplicação ou a criação de uma conta, o que pode ser redundante e desperdiçar tempo. Para evitar isso, podemos usar a habilidade do Selenium IDE de executar um script a partir de outro script, principalmente para um login, onde escrevemos um caso de teste que adicionamos à aplicação, e então chamamos este caso de teste nos outros scripts. Assim, escrevemos os passos de login apenas uma vez, e eles serão reutilizados em todos os casos de teste necessários. # Teste de Login com Selenium ID (Português de Portugal) Este documento descreve um teste de login utilizando a ferramenta Selenium ID. Ele demonstra como parametrizar usuários e senhas, executar testes de login com credenciais válidas e inválidas, e utilizar o depurador na ferramenta Selenium ID. ## Pré-requisitos - Navegador web compatível com Selenium ID - Selenium ID instalado ## Teste de Login com Credenciais Inválidas ### Etapa 1: Preparar o teste ``` Comandos: 1. Arquivo -> Novo Teste Suite 2. Criar um novo teste chamado `login_invalid_credentials. test` 3. Adicionar a URL do site de demonstração do login ``` ### Etapa 2: Definir os dados do usuário e senha inválidos ``` Comandos: 1. Armazenar usuário inválido: `user1` 2. Armazenar senha inválida: `pwd1` ``` ### Etapa 3: Executar o teste de login com credenciais inválidas ``` Comandos: 1. Armazenar alvo: `user1` alvo: `@username` 2. Armazenar alvo: `pwd1` alvo: `@password` 3. Executar alvo: `login. test` ``` ### Avaliar o resultado do teste Após a execução do teste, o Selenium ID mostrará um erro de login, indicando que as credenciais são inválidas. ## Teste de Login com Credenciais Válidas ### Etapa 1: Preparar o teste ``` Comandos: 1. Arquivo -> Novo Teste Suite 2. Criar um novo teste chamado `login_valid_credentials. test` 3. Adicionar a URL do site de demonstração do login ``` ### Etapa 2: Definir os dados do usuário e senha válidos ``` Comandos: 1. Armazenar usuário válido: `user3` 2. Armazenar senha válida: `pwd3` ``` ### Etapa 3: Executar o teste de login com credenciais válidas ``` Comandos: 1. Armazenar alvo: `user3` alvo: `@username` 2. Armazenar alvo: `pwd3` alvo: `@password` 3. Executar alvo: `login. test` ``` ### Verificar o resultado do teste Após a execução do teste, o Selenium ID deverá mostrar a tela principal do site, indicando que o login foi bem-sucedido. ## Utilização do Depurador 1. Para iniciar o depurador, Abra um novo teste e adicione o seguinte código: ``` - (suporte à execução de um teste com depurador) ``` 2. Execute o teste em depurador. 3. Depurar o teste passo a passo, utilizando as seguintes funções: - `step over current command: ` Executa apenas o comando atual e pára depois. - `Toggle breakpoint: ` Adiciona ou remove um ponto de interrupção. - `Run current test: ` Executa todos os comandos do teste até o ponto de interrupção, se houver. ## Observações finais Este documento descreve uma forma de executar testes de login usando Selenium ID. Ele demonstra como utilizar variáveis para parametrizar usuários e senhas, como executar testes de login com credenciais válidas e inválidas, e como utilizar o depurador da Selenium ID. Todas as credenciais de exemplo utilizadas neste documento devem ser substituídas por credenciais válidas na prática. # Gestão de Pontos de Paragem e Depuração em Automação de Teste Este guia demonstra o processo de adição, remoção e desativação de pontos de paragem, além de entrar no modo depurador e utilizar comandos depuradores em automação de teste usando uma única IDE específica. ## Adição de Pontos de Paragem ### Pontos de Paragem Manuais Para adicionar um ponto de paragem, pode-se realizar um dos seguintes passos: 1. Clique na linha onde você deseja adicionar o ponto de paragem. 2. Clique com o botão direito do mouse no comando e selecione "Togar Ponto de Paragem". ### Pontos de Paragem Programáticos Insira o comando `debugger` na posição desejada do seu script. Durante a execução, o script irá parar ao chegar a esse ponto e entrar no modo depurador. ### Opção "Executar até aqui" Clique com o botão direito do mouse no comando e selecione "Executar até aqui". Isso funcionará como um ponto de paragem e parará a execução no comando específico. ## Remoção de Pontos de Paragem Para remover um ponto de paragem, clique novamente na mesma linha onde o ponto de paragem foi adicionado ou selecione "Togar Ponto de Paragem" da lista de opções do botão direito do mouse. ## Desativação de Pontos de Paragem 1. No menu superior, selecione "Desativar Ponto de Paragem" (Observação: Isso quer dizer que o ponto de paragem será temporarymente ignorado durante a execução atual. Para reativar, basta deselecioná-lo. ) ## Depuração usando o tratamento de exceções A IDE inclui uma Features de "Pausar ao Ocorrer Exceção" que parará o script ao ocorrer uma exceção. Isso pode ser útil quando você quer corrigir a exceção e continuar a execução. Por exemplo, se um ID de elemento mudar e o script falhar em localizar o elemento devido a um ID não corresponhativo, a Feature de "Pausar ao Ocorrer Exceção" pode ajudá-lo a localizar o problema e corrigi-lo facilmente. ## Dicas e truques 1. Utilize título clareiros com adequados níveis (# para secções principais, ## para sub-secções e assim por diante). 2. Mantenha a formatação adequada e use a síntaxe Markdown, conforme necessário (texto em negrito, código, listas, separadores, etc. ). 3. Tenha cuidado de manter as URLs existentes, exemplos de código e referências intactas. 4. Corraje o texto de pouco a pouco, enquanto corrige erros de gramática e ortografia. 5. Seja cuidadoso com termos técnicos, comandos e códigos para garantir que não sejam mal utilizados ou ignorados. 6. Utilize adequadamente os cabeçalhos e cabeçalhos secundários para criar documentação bem estruturada. # Contador de Calórias Website Use Case Este caso de uso demonstra como interagir com um contador de calórias website usando o Selenium WebDriver. ## Objetivo O objetivo deste teste é simular a interação do usuário selecionando um género específico e um nível de atividade no contador de calórias website. ## Pré-requisitos - Selenium WebDriver (para automatizar interações com o website) - Um navegador em execução (por exemplo, Chrome, Firefox, Edge) - URL do Contador de Calórias Target (armazenado em uma variável para testes) ## Passos do Teste 1. Abrir o Contador de Calórias Website - Utilize o `open()` comando para abrir o website - URL: `<Your-Calorie-Counter-Website-URL>` 2. Armazenar o género selecionado - Utilize o `store()` comando para armazenar o género selecionado em uma variável, por exemplo, `gender` - Use o `if` condition para verificar se o género foi selecionado como 'feminino' ``` se ${gender} for igual a f então // selecione o botão de rádio feminino // selecione muito ativo como o nível de atividade fim se ``` - Se o género for selecionado como 'masculino', use o `else` condition para selecionar 'ativo' como o nível de atividade ``` caso contrário // selecione o botão de rádio masculino // selecione ativo como o nível de atividade fim caso contrário ``` 3. Executar o script de teste - Use o `execute()` comando para executar o script de teste - Modifique a velocidade de execução modificando o `setSpeed()` comando se necessário ## Exemplos Adicionais ### Laço While Este exemplo demonstra o uso de um laço `while` para executar operações num contador até que a soma de número alcançe um valor específico: ``` definir contador como 0 definir sum como 0 definir num1 como 5 definir num2 como 3 enquanto sum for menor que 30 definir sum como sum + num1 guardar sum num variável sum defere num1 num2 defere num2 num1 + 5 fim do enquanto ``` ### Laço Do-While Este exemplo demonstra o uso de um `do-while` para incrementar um contador e executar comandos específicos: ``` definir contador como 0 definir target como 50 faz defere contador em contador + 10 imprime contador CASO target seja menor que contador ``` ### time slot Este exemplo demonstra o uso de um `time slot` para executar um comando específico várias vezes: ``` definir contador como 100 definir target como 2 timeSet iterations to 2 incremento contador imprime contador ``` # Guide de configuração do Side Runner do Selenium Este guia detalha as etapas necessárias para configurar o Side Runner do Selenium em sua máquina. ## Prerequisito de instalação: Servidor Node. js ### O que é o Servidor Node. js? O Servidor Node. js é uma plataforma de JavaScript poderosa e amplamente utilizada por muitos desenvolvedores ao redor do mundo para desenvolver aplicações web e é gratuito e de código aberto para todos. ### Instalação do Servidor Node. js: Você pode encontrar o Node. js disponível para todas as plataformas na [página de download da Node. js](https://nodejs.org/). Se você estiver usando um computador com sistema operacional Windows, há duas opções: 1. Baixar e instalar o MSI instalador 2. Baixar e descompactar o zip e colocar em qualquer pasta de sua escolha Neste guia, será dado um exemplo para o Windows 64-bit. Após baixar o arquivo zip, ao clicar em ele, você será solicitado a enviar o arquivo para uma pasta de sua escolha. Descompacte o arquivo e a estrutura de pastas resultante terá a seguinte aparência: ``` node-v14. xx. xx-win-x64 node_modules npm ``` Neste caso, `node-v14. xx. xx-win-x64` é a versão do Node. js instalada. ### O que é npm? O `npm` é o gerenciador de pacotes do Node. js, que é um pacote para instalar todos os pacotes e módulos necessários na sua máquina. ## Instalação e verificação do Side Runner do Selenium Depois de ter instalado o Node. js, é necessário instalar o Side Runner do Selenium. Você pode fazer isso usando o npm. ```bash # Instalação do Side Runner do Selenium npm install -g selenium-side-runner ``` Para verificar se a instalação foi realizada com sucesso, execute o seguinte comando no terminal: ```bash selenium-side-runner -v ``` Isso deverá mostrar a versão do Side Runner do Selenium instalada. ## Localização do Side Runner do Selenium Após a instalação, o Side Runner do Selenium é instalado como um módulo no npm, e você pode localizá-lo na pasta `node_modules`. ``` node-v14. xx. xx-win-x64 node_modules npm ``` Neste caso, o Side Runner do Selenium será encontrado na pasta `node_modules`. ## Driver de navegador O Driver de Navegador é necessário para executar seus testes em vários navegadores diferentes. Você pode encontrar o Driver de Navegador correspondente para cada navegador na pagina de download do [SeleniumHQ](http://www.seleniumhq.org/download/). ### Executando os Testes Para executar os testes, você deve ter um arquivo com testes escrito em JavaScript que use o Side Runner do Selenium. Para executar os testes, você pode usar o seguinte comando no terminal: ```bash selenium-side-runner [nome_do_arquivo_com_testes] ``` Isso deverá iniciar a execução dos testes. # Selenium Side Runner Agora vamos ver o que acontece. Além disso, existe vários casos de teste aqui, então, veja-os todos esses casos de teste serão executados um após o outro sequencialmente. Assim, temos o caso do contador de calorias, seguido dos casos de teste em loop. Bem, isso foi feito, portanto, agora vamos entender a fluência deste caso de teste. ** Fluxo deste caso de teste** Neste ponto, começamos a rodar nossa suíte de teste. Acabou o primeiro caso de teste. Acabou o segundo caso de teste. Acabou o terceiro caso de teste. Em seguida, o quarto caso de teste. Portanto, todos os quatro casos de teste foram concluídos e ele diz que todos os quatro passaram. Além disso, mostra o tempo total tomado para a execução completa da suíte de teste e para cada caso de teste quanto é o tempo requerido para a execução. Assim que se usa o selenium side runner, você poderá ver a seguinte informação: > ** Suíte de Teste Completa** > > Todos os quatro casos de teste foram executados com sucesso. > > Total: 4 > > Tempo Total: <timestamps> > > Para cada caso de teste: > > ** Caso de Teste #1** > > Tempo: <timestamp> > > ** Caso de Teste #2** > > Tempo: <timestamp> > > ** Caso de Teste #3** > > Tempo: <timestamp> > > ** Caso de Teste #4** > > Tempo: <timestamp> Em caso de falha em qualquer fase de teste, isso será refletido aqui. Diz-se que "[esta é] a relação de teste que você verá. " ## Usando o selenium side runner em vários processos Se você tiver vários controladores de navegadores instalados e quiser executá-los em um navegador específico, use o comando abaixo. Não pode esquecer que você precisa instalar o navegador dessa forma: ``` selenium-side-runner --c --capabilities "browserName=<browser_name>" <project_name> ``` Dê um exemplo: ``` selenium-side-runner --c --capabilities "browserName=chrome" meu_projeto ``` Se o navegador estiver instalado, agora execute esta suíte de teste em esse navegador específico. Você também poderá criar um script shell ou um script de lote com esta linha para executar testes em vários navegadores. Isso é útil para testes de navegadores cruzados. ## Execução em paralelo Para executar os casos de teste em paralelo, siga esses passos: Siga até a configuração do seu projeto e selecione o checkbox "Rodar em paralelo". Salve o projeto. Agora, repita o projeto sobrepondo-o, mas agora com a opção "Rodar em paralelo" incluída. É preciso substituir o projeto anterior. Agora, no seu terminal, rode novamente os testes. Quando você analisar o número de janelas do navegador Chrome que serão abertas, você notará que o número de janelas do navegador Chrome será maior em comparação à execução sequencial. Neste exemplo, foi aberto três janelas do navegador Chrome ao mesmo tempo. ! [Screenshot de exemplo com 3 janelas do navegador Chrome abertas paralelamente](https://your-screenshot-url.com) Enquanto você pode não perceber uma diferença significativa em execução para testes individuais, caso seus testes sejam maiores ou mais complexos, você terá uma diferença significativa de tempo de execução. ## Limitações Você não pode exportar seus scripts do IDE para scripts Web Driver. Essa característica já foi adicionada, mas está sendo trabalhada ainda. De forma geral, o selenium IDE não permite testes em batch, testes de dados, testes de banco de dados e reportes melhores. Não há suporte para a criação de arquivos JUnit, Python ou execução de testes em paralelo com reportes melhorados. É recomendável usar o selenium Web Driver em vez disto. ## Selenium Web Driver O selenium Web Driver é uma das componentes mais importantes do conjunto de ferramentas Selenium quando falamos em criar um todo suite de regresso. Quando falamos em Selenium Web Driver, ele nos permite a capabilidade de testar a compatibilidade entre os navegadores, o que significa que, caso você queira testar sua aplicação, pode criar um teste para o navegador Chrome, um teste para o navegador Firefox e um teste para o Internet Explorer. Se um navegador novo, como Safari, for lançado, você poderá usar o mesmo script com o Web Driver do Safari. Esse Web Driver não é apenas estático para um navegador individual, ele pode abordar vários navegadores, o que aumenta a compatibilidade. Assim, mesmo que você esteja escrevendo seus testes em caso de Selenium, sabemos que sua suíte de teste não será limitada a um navegador individual, o que significa uma compatibilidade adicional em média. O selenium Web Driver também fornece suporte a várias linguagens de programação. Por exemplo, você poderá escrever seus testes usando Java ou c#. Além disso, o Web Driver fornece suporte a várias placas de sistema como o Windows, o Linux e o MacOS. Você também pode obter uma execução mais rápida de seus testes de script, pois estamos falando aqui de automações na Web, não de implementações. Assim, quando falamos de automações aqui, o Web Driver nos ajuda a executar testes de forma mais rápida. Como vista aqui, os selenium web drivers fornecem múltiplas benefícios, desde a execução mais rápida de testes a compatibilidade completa com vários environmentos de programação. # Selenium WebDriver vs Selenium Remote Control (RC) e Selenium Ide Selenium WebDriver é uma ferramenta popular usada para criar aplicações web automatizadas. No entanto, é importante entender as diferenças entre ele e outras soluções, como Selenium Remote Control (RC) e Selenium Ide. ## Selenium Remote Control (RC) Selenium Remote Control não é utilizado mais com frequência pois a maioria das funções já se encostraram para o Selenium WebDriver. A migração de Selenium Remote Control para WebDriver ocorreu devido a seguintes razões: 1. Compatibilidade: Selenium WebDriver é compatível com diversos navegadores, oferecendo uma maior compatibilidade. 2. Independente do servidor: Selenium WebDriver não requer a inicialização de um servidor, diferentemente de Selenium RC onde a comunicação ocorre por meio de um servidor. 3. API-baseado: Selenium WebDriver é uma API e não requer um plugin baseado em GUI adicional. Isso o torna mais eficiente ao lidar com integrations, especialmente com aplicações modernas que trabalham em um formato de API. 4. Orienta-objeto: Selenium WebDriver é orientado a objetos, tornando-o mais fácil de lidar e mais eficiente para os desenvolvedores. 5. Suporte a múltiplos ouvintes: Selenium WebDriver suporta múltiplos ouvinte, o que não é disponível em Selenium RC. 6. Teste de iOS e Android: Selenium WebDriver permite o teste de aplicações de iOS e Android, algo que não é disponível em Selenium Ide. ## Selenium Ide Selenium Ide é um plugin que oferece um mecanismo de gravação e reprodução de testes Selenium. É integrado com o motor JavaScript, e além de having-setup adicional além da instalação de um browser, é necessário. Ele fornece modo de depuração, tornando fácil a depuração de problemas e a gestão de exceções. Selenium Ide é um pacote maior que inclui vários componentes, oferecendo uma variedade de recursos. No entanto, é importante notar que Selenium WebDriver é diferente de Selenium Ide e Selenium RC em alguns aspectos chave: 1. Compatibilidade com navegadores: Selenium WebDriver é compatível com diversos navegadores, oferecendo compatibilidade em navegadores diferentes. 2. Arquitetura: A arquitetura do Selenium WebDriver consiste em selenium language bindings, JSON wire protocol e browser drivers. Ele se conecta aos navegadores reais (como Chrome, Firefox e mais) através desses drivers de navegador. 3. Linguagens de programação: Selenium WebDriver suporta uma variedade de linguagens de programação, como Java, Python, Ruby, C#, e JavaScript. 4. Suporte da comunidade: Selenium WebDriver conta com uma comunidade de desenvolvedores grandes que podem ajudar e contribuir para o projeto. 5. Teste cruzado de dispositivos: Selenium WebDriver suporta teste cruzado de dispositivos para ambas as plataformas de desktop e móveis. Em resumo, enquanto Selenium Ide, Selenium RC, e Selenium WebDriver são todas soluções do ecossistema do Selenium, Selenium WebDriver diferencia-se pela sua compatibilidade com vários navegadores, suporte à várias linguagens de programação, comunidade, e seus recursos de teste cruzado de dispositivos. Recursos: - [Documentação oficial do Selenium WebDriver](https://www.selenium.dev/) - [Arquitetura do Selenium WebDriver](https://selenium-project.github.io/webdriver/guide/architecture.html) # Selenium Web Driver Utilização e Suas Desvantagens Este documento vai guiar você através da utilização do Selenium Web Driver, seus benefícios e potenciais desvantagens. ## Introdução Neste texto, vamos discutir como utilizar o Selenium Web Driver para estabelecer comunicação entre bibliotecas e controladores de web drivers, executar o Protocolo JSON Wire e gerenciar controladores de navegador para interagir com determinados navegadores de acordo com a linguagem de programação. ### Utilizando o Protocolo JSON Wire 1. Use o Protocolo JSON Wire como conector entre bibliotecas e controladores de web drivers. 2. Interaja de forma programática com a ajuda de bibliotecas cliente para enviar solicitações aos controladores de web drivers. 3. Permite a transferência de dados entre um servidor e cliente, garantindo o processamento adequado dos resultados finais. 4. Execute o Protocolo JSON Wire para estabelecer comunicação e conectividade. ### Controladores de Navegadores - Os controladores de navegadores do Selenium são específicos para cada navegador. - O Protocolo JSON Wire conecta-se aos navegadores específicos através dos controladores, permitindo a interação com o navegador exato. - Se você deseja interagir com o Chrome, use o Controlador do Chrome; se desejar utilizar o Firefox, use o Controlador do Firefox. ### Execuções e Navegadores - Após as execuções serem concluídas, você poderá ver vários navegadores sendo abertos de acordo com o navegador ou controlador utilizado. - Por exemplo, se você utilizar o Chrome, o navegador Chrome será inicializado; se utilizar o Firefox, o navegador Firefox será inicializado. ## Desvantagens do Selenium Web Driver O Selenium Web Driver apresenta algumas desvantagens, principalmente: 1. Limitações para Aplicações Desktop: O Selenium Web Driver foi projetado apenas para aplicações web e não funciona com aplicações desktop. 2. Exigência de Experiência: Gerenciar scripts do Selenium requer um determinado nível de experiência em programação. 3. Falta de Mecanismo de Relatórios: O Selenium Web Driver não possui um mecanismo de relatórios integrado. No entanto, é possível integrá-lo com JUnit e TestNG para gerar relatórios de teste. ## Integração Para aproveitar ao máximo o Selenium Web Driver, integre-o com outras ferramentas de teste, como JUnit e TestNG, para melhores capacidades de relatório. Esta solução personalizada permite combinar os componentes principais do Selenium com componentes adicionais como TestNG e JUnit para uma experiência de teste completa. ## Manutenção e Escalabilidade A manutenção e a escalabilidade do Selenium Web Driver podem ser desafiadoras, pois exigem uma equipe de especialistas dedicada e consumem um esforço considerável de gerenciamento e manutenção. ## Teste de Compatibilidade de Navegadores Cruzado O Selenium Web Driver oferece teste de compatibilidade de navegadores cruzado para diferentes solicitações em navegadores, mas carece de capacidades de teste de imagem. Integrar o Selenium com ferramentas adicionais para superar esta limitação e testar imagens também. ## Conclusão Embora o Selenium Web Driver tenha suas desvantagens, como limitações em teste de aplicações desktop e a necessidade de conhecimentos em programação, integrá-lo com outras ferramentas de teste pode ajudar a compensar essas desvantagens. Com planos cuid # Guia de configuração do Selenium com Eclipse Este guia te orientará passo a passo na configuração do Selenium com o Eclipse. ## Pré-requisitos - O Selenium e o Eclipse são aplicações abertas de código. Você pode os encontrar em suas respectivas paginas de doação, mas também é possível utilizá-los gratuitamente. - Java Runtime Environment (JRE) é necessário. Se não possuí-lo instalado, você pode baixá-lo na [website da Oracle Java](https://www.oracle.com/java/technologies/javase-jre8-downloads.html). - Motoristas de navegadores: Para Firefox, pode-se encontra-lo na [website da Mozilla](https://github.com/mozilla/geckodriver/releases); para Chrome, pode-se encontrar na [website do ChromeDriver](https://chromedriver.chromium.org/downloads). - Bindefins de Selenium: Estes podem ser baixados na [website de Selenium](https://www.selenium.dev/downloads/). ## Passos 1. Instale o Eclipse: Baixe o instalador do Eclipse para o seu sistema operacional e execute-o. siga as instruções de instalação. 2. Configure o Eclipse: Após a instalação concluída, abra o Eclipse. Verifique se uma JVM (Máquina Virtual Java) está disponível e que o comando de linha de Java está funcionando. 3. Instale o Java Development Kit (JDK): Você pode baixar o JDK na [website da Oracle Java](https://www.oracle.com/java/technologies/javase-jdk15-downloads.html). Durante a instalação, certifique-se de escolher a opção **Standard (JDK)** em vez da opção **Developer Pack (JDK & JRE)**, pois já possui JRE instalado. 4. Instale Motoristas de Navegador (opcional): Se necessário, motoristas para o Chrome ou Firefox, siga os links proporcionados acima para baixar. 5. Baixe os Bindefins de Selenium: Vá para a [website de Selenium](https://www.selenium.dev/downloads/) e baixe os binds para o idioma de programação desejado. 6. Integre os Bindefins do Selenium à sua projecto do Eclipse: Descompacte o arquivo baixado e adicione as ferramentas necessárias ao seu projeto no Eclipse. 7. Crie um novo projeto do Java: No Eclipse, vá a `Arquivo` > `Novo` > `Projeto do Java`. Nomeie seu projeto e escolha o JDK que deseja utilizar. 8. Escreva seu código do Selenium: Quando o seu projeto estiver preparado, você pode começar a escrever o seu código do Selenium para interagir com o navegador da web. Assim que terminou, você conseguiu configurar o Selenium com o Eclipse. Agora você pode começar a escrever testes de casos para automatizar aplicações da web. # Guia de Configuração do Selenium Web Driver Este guia vai te levar por meio do processo de configuração de um projeto do Selenium Web Driver usando o Eclipse. ## Criando um Novo Projeto Java Primeiro, crie um novo projeto Java. Enquanto iremos gerenciar configurações de caminho de build mais tarde, vamos focar nos passos iniciais de criação de um novo arquivo de classe. ## Escolhendo um Navegador e Motor de Driver Pode escolher qualquer navegador e motor de driver que desejar, como Firefox, Chrome ou Edge. Os passos abaixo demonstram o processo para Firefox. 1. Verifique se que o navegador Firefox está instalado. Se não estiver instalado, você pode baixá-lo aqui: [Site de Download Oficial do Firefox](https://www.mozilla.org/en-US/firefox/new/) 2. O motor de driver adequado para o navegador Firefox pode ser baixado aqui: [GeckoDriver](https://github.com/mozilla/geckodriver/releases) (Para Windows 64-bit) 3. Extraia o arquivo . zip baixado e localize o arquivo GeckoDriver. exe. ## Adicionando o Motor de Driver ao Eclipse 1. No Eclipse, clique com o botão direito do mouse no seu projeto e vá para "Configuração de Caminho de Build" > "Configurar Caminho de Build". 2. Clique novamente em "Configurar Caminho de Build" e depois selecione "Bibliotecas". 3. Clique em "Adicionar Arquivos Externos" e adicione o arquivo GeckoDriver. jar do arquivo . zip baixado. 4. A localização relativa do arquivo GeckoDriver. jar no seu projeto deve ser definida. Se precisar de ajuda, consulte a seção abaixo sobre a configuração de variáveis de caminho de classe. ## Criando um Arquivo de Classe Crie um pacote chamado `calm` e, dentro do pacote, crie um arquivo de classe chamado `SeleniumTest`. Você pode usar nomes personalizados para o pacote e o arquivo de classe de acordo com sua preferência. ## Configurando Variáveis de Caminho de Classe 1. No Eclipse, vá para "Projeto" > "Propriedades". 2. Na janela "Propriedades", vá para "Caminho de Build" > "Bibliotecas". 3. Clique em "Adicionar Variável de Caminho de Classe" e insira o caminho adequado para o seu arquivo GeckoDriver. exe. ## Executando o Suite de Testes 1. Clique com o botão direito do mouse no seu arquivo `SeleniumTest` e selecione "Executar Como" > "Aplicação Java". 2. (Opcional) Se você encontrar erros relacionados a importações faltantes, adicione as dependências necessárias, que podem ser encontradas no arquivo . zip baixado. Esteja pronto! Seu projeto do Selenium Web Driver agora está pronto para uso. Você pode continuar escrevendo casos de teste no seu arquivo `SeleniumTest` para automatizar testes para diferentes navegadores. ## Notas Adicionais - Verifique se que você tem o Java 8 instalado antes de executar testes do Selenium 3. 0. 3. - Você pode baixar a versão mais recente do Selenium (3. 5. 3) do [site do Selenium](https://selenium-release.storage.googleapis.com/index.html). - Vamos abordar o TestNG em um tutorial futuro sobre frameworks de teste de unidade. Para agora, não é necess # Criando um pacote e organização de pastas Este guia irá mostrar-lhe como criar um novo pacote e organizar pastas para um projeto Selenium em Eclipse utilizando formatação Markdown. ## Criando um novo pacote 1. Primeiro, crie um novo pacote. Utilizaremos um pacote existente chamado `selenium examples`, então clique com o botão direito do rato no `test` pasta fonte e crie uma nova pasta chamada `resources`. ``` Clique com o botão direito > Novo > Pasta Nome: resources ``` 2. Em seguida, crie outra pasta no projeto e chame-a `slip`. ``` Clique com o botão direito > Novo > Pasta Nome: slip ``` ## Organização de pastas ### Pastas resources - Esta pasta contém todos os controladores (por exemplo, Chrome driver, driver Firefox, etc. ). ### Pastas slip - Esta pasta armazena todas as bibliotecas Selenium. ## Adição de bibliotecas ao projeto Existem dois métodos para adicionar bibliotecas ao projeto: ### 1. Adicionando arquivos JAR externos 1. Vá às propriedades do projeto. 2. Navegue até Java Build Path > Bibliotecas > Adicione Arquivos JAR externos. 3. Selecione as bibliotecas que deseja adicionar. ### 2. Adição de bibliotecas à pasta lib 1. No seu projeto, crie uma nova pasta chamada `lib`. 2. Baixe as bibliotecas e cole-as na pasta `lib`. 3. Clique com o botão direito no arquivo da biblioteca e selecione "Adicionar ao caminho de compilação". ## Adição de controladores à pasta resources 1. Baixe e extraindo os controladores necessários (Jacoby driver, Chrome driver, Firefox driver, e o Driver Internet Explorer). 2. Cole os controladores baixados e cole-os na pasta `resources`. ## Aprendendo XPath [A partir deste momento, você aprenderá sobre XPath e sua relevancia, sintaxe, tipos, funcionais, e acesso no automação Selenium. ](https://www.youryoutubechannel.com/video/XPathTutorial) Por favor, inscreva-se no nosso canal do YouTube e clique no ícone de sino para atualizações. --- # Caminho XPath Relativo e Funções XPath em Selenium (Português de Portugal) Este texto explica como o Caminho XPath Relativo permite-lhe escrever caminhos de pesquisa a partir da estrutura DOM HTML interna sem necessidade de escrever um XPath longo. Aqui estão os pontos chave, configurados e corrigidos com Markdown: ```markdown O Caminho XPath Relativo permite-lhe escrever a partir da estrutura do DOM HTML interno sem qualquer necessidade de escrever um XPath longo. A sintaxe do Caminho XPath Relativo tem a seguinte aparência: ```javascript //O caminho relativo deve ser combinado com outro caminho para acessar um ficheiro a criação de um link para um caminho absoluto é fácil, pois estás a apontar para o URL da internet do ficheiro ``` Paralocalizar um ficheiro específico, certas considerações devem ser tomadas, em particular: 1. O ficheiro deve existir no mesmo servidor que o ficheiro HTML. 2. O caminho do ficheiro deve ser relativo ao diretório do ficheiro HTML. Isso resume os dois tipos de caminhos para nós. ## Funções XPath O termo **Função XPath** refere-se às funções fornecidas por Selenium para escrever expressões XPath eficientes para descobrir elementos de forma única. Quando as estrategias XPath básicas não são eficientes devido a elementos que compartilham propriedades semelhantes, como o mesmo nome ou classe, as funções XPath tornam-se necessárias. Há três tipos de funções XPath: 1. **Contém XPath**: A função de contém XPath é usada para pesquisar elementos web que contenham um determinado texto. Pode encontrar elementos com texto parcial, útil quando a parte do valor de qualquer atributo muda de forma dinâmica. Sintaxe: ```javascript // utilize o método contains para encontrar elementos que contêm um substring especificado. ``` 2. **Texto XPath**: A função Texto XPath é usada para localizar um elemento com base no texto do elemento web. Ajudou-me a encontrar o elemento de texto exato. Sintaxe: ```javascript // utilize o método text para localizar o texto do elemento web quando identificado pelo seu nome de tag e comparando com a parte direita do seu valor. ``` 3. **Começa com XPath**: A função Começa com XPath é usada para encontrar um elemento em que os valores dos atributos começam com algum caractere ou sequência específica. É importante enquanto trabalha com páginas web dinâmicas. Sintaxe: ```javascript // utilize o método starts-with para encontrar elementos que começam com uma string especificada. ``` ## Eixos XPath Os elementos XML DOM estão em estrutura hierárquica e XPath fornece atributos específicos chamados Eixos XPath para localizar elementos dinâmicos que são impossíveis de encontrar com métodos XPath normais, como id, classe, etc. Páginas dinâmicas Aqui alguns exemplos de Eixos: - **Pai**: Seleciona todos os elementos pai (pai, avô, etc. ) do nó atual. - **Pai ou Esta**: Localiza o nó atual e seus ancestrais. - **Atributo**: Define os atributos do nó atual. - **Filho**: Seleciona todos os filhos dos elementos do nó atual. - **Descendente**: Localiza os filhos do nó atual até o nó folha. - **Descendente ou Esta**: Localiza o nó atual com os seus descendentes. - **Fica depois**: Localiza todos os nós que followem o nó atual. - **Pai**: Localiza o pai do nó atual. - **Este**: Localiza o nó atual. E outros, como Anterior, Sistema Irmão seguinte e Anterior irmão. menor (\* `) ! = Europa (não é necessário alterar caracteres especiais para código Markdown). Ao copy and paste, certifique-se de que mantém os espaçamentos, que servem para que sejam mantidos corretamente. # Guia de Download e Instalação do Selenium (Java) Utilize o Selenium para processar aplicações web. Aqui está como baixar e instalar o Selenium para Java. ## Conteúdos - [Baixar o Selenium](#baixar-selenium) - [Extract Selenium Zip File](#extract-selenium-zip-file) - [Adicionar bibliotecas do Selenium no Eclipse](#adicionar-bibliotecas-do-selenium-no-eclipse) - [Importar bibliotecas do Selenium](#importar-bibliotecas-do-selenium) - [Adicionar biblioteca JUnit](#adicionar-biblioteca-junit) - [Configurar o ChromeDriver](#configurar-chrome-driver) - [Executar Caso de Teste](#executar-caso-de-teste) --- ## Baixar o Selenium <a name="baixar-selenium"></a> Acceeda à [página do website do Selenium](https://www.selenium.dev/downloads/) e baixe a versão adequada (3. 1. 0 neste exemplo) para a sua plataforma. É possível também optar pela versão beta, mas este guia irá se concentrar na versão estável. --- ## Extract Selenium Zip File <a name="extract-selenium-zip-file"></a> Extraia o ficheiro . zip baixado em uma pasta convenientemente localizada. Os ficheiros extraídos do Selenium conterão vários ficheiros de biblioteca que são dependências necessárias. --- ## Adicionar bibliotecas do Selenium no Eclipse <a name="adicionar-bibliotecas-do-selenium-no-eclipse"></a> Depois de criar um novo projeto Java no Eclipse, siga as seguintes etapas para adicionar as bibliotecas do Selenium: ### Importar bibliotecas do Selenium <a name="importar-bibliotecas-do-selenium"></a> 1. Clique com o botão direito no **Path de Build Java** e clique em **Configurar Path de Build**. 2. Va para a aba **Bibliotecas**. 3. Clique em **Adicionar Bibliotecas Existentes** e selecione as bibliotecas do Selenium no directório extraído. ### Adicionar biblioteca JUnit <a name="adicionar-biblioteca-junit"></a> 1. No **Configurar Path de Build** clique numa entrada Java Build Path. 2. Na aba **Bibliotecas** clique em **Adicionar Biblioteca** e selecione a biblioteca JUnit. 3. Se a biblioteca JUnit não estiver presente na lista, pode ser adicionada permitindo importá-la manualmente clicando em **Adicionar Bibliotecas Existentes**, seleciona o `junit-X. X. X. jar` arquivo e inicia a adição à pasta de Live Editor. --- ## Configurar o Chrome Driver <a name="configurar-chrome-driver"></a> 1. Será necessário baixar o ChromeDriver para a sua plataforma, se não estiver a usar Windows. 2. Coloque o executável do ChromeDriver na mesma pasta que o seu projeto Java. 3. Atualize o caminho do ChromeDriver no seu código Java de acordo. Por exemplo, `System. setProperty("webdriver. chrome. driver", "path/para/chromedriver. exe"); ` --- ## Executar Caso de Teste <a name="executar-caso-de-teste"></a> 1. Clique com o botão direito na sua classe de teste Java e clique em **Executar Como** > **Teste JUnit**. 2. O caso de teste iniciará a correr e deverá iniciar uma nova instância do browser Google Chrome. 3. Se o teu caso de teste foi adicionado corretamente, deverás ver o browser abrir e agir conforme a cenário de teste definido. Esta é a saga! Tens bem sucedidamente configurado e executado o Selenium com Java e Eclipse. Felizes com os testes da web! 🤓 💻 # Configurando o Navegador Chrome com Selenium para Testes JUnit em Português de Portugal (manter a formatação Markdown) A instalação do JDK, Eclipse, Selenium e o navegador Chrome já estão integrados com um IDE e o JDK. Este processo é relativamente fácil de executar. Aqui está um passo a passo sobre como configurar o navegador Chrome: 1. **Baixar e Configurar Selenium** - O Selenium é a parte mais crucial desta configuração. Pode baixá-lo na [Website Oficial]. Após o download, siga as seguintes instruções para incluí-lo em seus projetos: 2. **Entendendo Anotações** - As anotações são essenciais para tornar nossos testes mais reutilizáveis e manuteníveis. Elas ajudam a adicionar funcionalidades aos nossos testes com facilidade. 3. **Visão Geral de TestNG** - O TestNG é um framework de testes para Java. É uma alternativa ao JUnit e vem com mais funcionalidades. 4. **Pré-requisitos para o TestNG** - Antes de entrar no TestNG, aqui está algumas coisas que você deve saber: - Preston G é uma estrutura de testes unidade no Java. A sua forma completa é Next Generation (NG). Existem dois frameworks de testes unidade populares no Java: JUnit e TestNG. - JUnit 4 é a versão mais recente do JUnit e a versão 6. 7 é a versão mais recente do TestNG. É esperado que uma nova versão, TestNG 6. 8, seja lançada sob brevete, que pode ser tão avançada ou equivalente ao TestNG atual. 5. **Anotações do TestNG** - O TestNG oferece várias anotações que nos ajudam a tornar nossos testes mais eficientes e manuteníveis. Aqui estão algumas anotações disponíveis no TestNG: - `@BeforeSuite`: Executar antes de todas as suites de teste - `@BeforeTest`: Executar antes de cada teste - `@Test`: Executar o caso de teste - `@AfterTest`: Executar depois de cada teste - `@BeforeClass`: Executar antes de cada classe - `@AfterClass`: Executive depois de cada classe - `@BeforeMethod`: Executar antes de cada método - `@AfterMethod`: Executar depois de cada método - `@BeforeGroup`: Executar antes de um grupo de testes, definido por grupos(@Test(groups={"group1"})) - `@AfterGroup`: Executive depois de um grupo de testes - `@DataProvider`: Utilizado para fornecer dados aos testes, especialmente em testes orientados a dados - `@Parameters`: Utilizado para passar parâmetros aos testes, especialmente em testes parametrizados **Baixar o TestNG** - Para baixar o TestNG, siga estes passos: 1. Entre no **Ajuda** no seu IDE do Eclipse. 2. Clique em **Mercado de Pessoalizações**. 3. Pesquise pelo **TestNG**. 4. Clique em **Instalar**. 5. Após instalado, o TestNG será disponível para uso em seu projeto. 6. **Design do Objeto de Página** - Com o padrão de Design de Objeto de Página, criamos um objeto para cada página da web. Isso nos torna nossos testes mais legíveis e manuteníveis. 7. **Práticas recomendadas do TestNG** - - Crie uma classe de objeto de página para cada página da web. - Cada método da classe do objeto de página deve retornar o objeto da página ou retornar o objeto do próximo objeto de página. - Garanta que cada objeto de página valide se a página foi carregada corretamente antes de dar controle para o próximo passo. - Evite codificar quaisquer dados utilizados pelo objeto de página e passe-os por meio do teste. # UI Testing: Princípios Diretores e Selenium vs. QTP (Quick Test Professional) Este guia oferece uma visão geral dos cinco princípios diretores para teste de interface de usuário, seguido por uma comparação entre dois ferramentas de teste de software populares, Selenium e QTP. ## Princípios Diretores para Teste de UI Mantere a criação de suítes de testes mantendo um enfoque a longo prazo no primeiro princípio, ao mesmo tempo que tentar seguir todos os princípios de teste de UI. Utilize o primeiro princípio como uma orientação em vez de uma regra rígida para garantir que as suítes de testes sejam manuteníveis: - **Rápido: ** Garanta que os testes sejam executados eficientemente e opte por otimizar o código para tempos de execução rápidos. Tente evitar a dependência de esperas explícitas em qualquerlocal onde possível, para evitar o tempo perdido. - **Isolado: ** Minimize a dependência entre os testes, e tente criar testes autônomos que a execução do teste não dependa de uma sequência específica de testes ou do sucesso/falha de outro teste. - **Independente: ** Tente minimizar a dependência de teste inter-test como bem como possível, de forma que um único teste não dependa de outro teste ou da fase de configuração/destruição para execução. Isso permite que você execute livremente qualquer combinação de testes. - **Repetível: ** Crie testes configuráveis de forma que produzam resultados consistentes cada vez que forem executados e use dedica métodos para conter separadamente os passos de cada teste, para minimizar as dependências e aumentar a reutilização dos métodos de testes individuais. - **Autovalidante: ** Garanta que os testes contenham um mecanismo de validação ou ação de verificação dentro de cada teste que confirme se o teste passou ou falhou baseado em condições conhecidas, de forma que os scripts de teste sejam executados sem a intervenção do usuário. ## Comparando Selenium e QTP Ambos Selenium e QTP (Quick Test Professional) são ferramentas utilizadas na indústria de teste de software. ### Selenium Selenium é uma ferramenta de teste de aplicação web e comercial: 1. **IDE: ** O Entorno de Desenvolvimento Integrado (IDE) do Selenium, ou plugins como IDE-for-Chrome e Selenium-WebDriver oferecem opções de teste rápidas e amigáveis ao usuário através de sua função de registo e reprodução. 2. **WebDriver: ** Teste cruz-browser que suporta uma variedade de navegadores e permite aos desenvolvedores criar testes automáticos com várias linguagens de programação como Java, Python e Ruby. 3. **Grid: ** Permite a execução de teste em diversas plataformas, permitindo executar testes simultaneamente e remotos em vários dispositivos ou navegadores. 4. **WebDriverIO, Appium: ** Ferramentas adicionais que oferecem funcionalidades melhoradas, integração fazPlease edit and format this translation to maintain Markdown format. Corrected translation: 1. **IDE: ** O Ambiente de Desenvolvimento Integrado (IDE) do Selenium, ou plug-ins como IDE-for-Chrome e Selenium-WebDriver fornecem opções de teste rápidas e amigáveis ao usuário através de sua função de gravação e reprodução. 2. **WebDriver: ** Teste cruz-navegador que suporta uma variedade de navegadores e permite aos desenvolvedores criar testes automáticos com várias linguagens de programação como Java, Python e Ruby. 3. **Grid: ** Permite a execução de testes em várias plataformas, permitindo executar testes simultaneamente e remotamente em vários dispositivos ou navegadores. 4. **WebDriverIO, Appium: ** Ferramentas adicionais que oferecem funcionalidades melhoradas, integração fácil com navegadores e dispositivos móveis, e geração de relatórios em tempo real. sesão com web e móveis incorporados, bem como generating relatórios em tempo real. ### QTP (agora UFT, Testes Funcionais Unificados) O QTP, desenvolvido pela Hewlett-Packard (agora HPE), oferece recursos para aplicações de escritório adicionais: 1. **HP QuickTest Professional (QTP): ** Ferramenta comercial projetada para testar aplicativos web e de escritório. Emprega scripts Visual Basic para fins de automação e permite que o usuário teste e resolva quaisquer problemas funcionais nas aplicações, serviços ou aplicações web. 2. **Testes Funcionais Unificados (UFT): ** Suite de testes integrada que combina testes funcionais da web (anteriormente conhecido como QTP), testes de carga (LoadRunner), e testes de aplicações móveis. O UFT tem suporte nativo para integração com sistemas de integração continua como Jenkins, Hudson, etc. , bem como para plataformas de testes móveis, incluindo Android, iOS, Windows Mobile, BlackBerry OS, etc. Ambas as ferramentas permitem aos desenvolvedores conseguirem resultados eficazes para teste de aplicações web. Utilize Selenium quando você procura automação gratuita e aberto ou utilize o QTP se você está procurando uma ferramenta comercial completa com suporte integrado para funcionalidades de teste de carga, carregamento, móvel e gestão de testes. # Documentação do Selenium ## Nível Básico de Perguntas ### Question 1: Componentes do Suite do Selenium O Selenium é uma potente ferramenta de automação de aplicações web. Ele consiste em quatro componentes principais: 1. **Selenium IDE**: O elemento mais simples do conjunto, o Selenium IDE é um ambiente de desenvolvimento integrado (IDE) que fornece uma functionalidade de registro e reprodução. Originalmente disponível como um plugins do Firefox, a versão nova do IDE do Selenium também está disponível como extensão do Chrome e plugins do Firefox. Esta nova IDE vem com diversas funcionalidades novas, tornando-a mais potente que a versão anterior. Algumas das novas funcionalidades incluem a reutilização de casos de teste, um melhor depurador e suporte para execução de testes paralelos. 2. **Selenium Remote Control (RC)**: O Selenium RC é utilizado para escrever testes de aplicações web em várias linguagens de programação. Ele suporta múltiplos idiomas de programação como Java, C, Perl, Python, Ruby e PHP. O Selenium RC é essencialmente um servidor que interage com o seu navegador utilizando simples requisições HTTP GET e POST para comunicação. 3. **Selenium WebDriver**: Uma interface de programação para executar os seus testes, o WebDriver foi introduzido por Simon Stewart em 2006. Ele foi criado para superar algumas das limitações do Selenium RC. O WebDriver interage diretamente com o navegador e faz os seus testes executar muito mais rápido que o RC. A arquitetura do WebDriver é mais simples porque remove a dependência do servidor adicional necessário para a comunicação com o navegador. 4. **Selenium Grid**: Uma ferramenta importante, o Selenium Grid permite a execução de múltiplos scripts de teste em múltiplas máquinas ao mesmo tempo. Com o WebDriver, você pode executar apenas execuções sequenciais. No entanto, em ambientes reais, sempre se precisa de executar casos de teste em um ambiente de execução distribuído. O Selenium Grid permite a execução paralela de testes em diferentes navegadores e diferentes sistemas operativos. ### Question 2: Limitações do Selenium Como qualquer outra ferramenta, o Selenium também tem determinadas limitações. Aqui estão algumas das limitações mais importantes e seus ecfeitos substitutos: 1. **Sem suporte técnico confiável**: Como o Selenium é uma ferramenta open source, não há suporte técnico disponível. No entanto, existem diversos recursos de documentação e fóruns disponíveis, como seleniumhq. org, que você pode consultar para obter suporte. 2. **Não pode testar aplicações GUI Windows**: O Selenium foi criado para automatizar bases de aplicações web em diferentes navegadores. No entanto, ele não é capaz de lidar com pop-ups Windows-based no aplicativo. A alternativa para isso é integrar outras ferramentas como o AutoIT para a solução de atividades Windows-based. 3. **Limitação para testes de imagem**: O Selenium não é a ferramenta de testes de imagem de fato, pois a API padrão permite apenas interações com o navegador. Uma alternativa boa para testes de imagem é a ferramenta Sikuli, que pode ser integrada com segurança com o Selenium. 4. **Não dispõe de uma capa manager de relatórios**: O Selenium não dispõe de nenhuma capacidade de geração de relatórios. No entanto, ele apoiará ferramentas como TestNG ReportNG e Extent Reports, que podem ser integrados para gerar excelentes relatórios. 5. **Limitação em gerenciamento de teste**: O Selenium não proporciona qualquer integração de testes com ferramentas de gerenciamento de testes. No entanto, pois o Selenium suporta vários idiomas de programação, o desenvolvedor da automação de testes requer apenas básica conhecimento de qualquer uma das linguagens de programação corrente. ### Question 3: Tipos de Testes Suportados por Selenium O Selenium suporta testes de regressão e testes funcionais. O teste de regressão envolve a execução parcial ou total de casos de teste já executados para garantir que as funções existentes não quebram. O teste funcional envolve identificar os inputs de teste, os resultados esperados, a logica dos testes própria e as afirmatividades. ### Question 4: Selenium 2. 0 e Suas Versões Filhas Introduzido por Jason Huggins em 2004, o Selenium veio Anglo um salto a frente em termos de automação de navegadores pela introdução do API WebDriver. O Selenium RC era desvantajoso pelo necessitar de um servidor adicional para falar com os navegadores web, o que ligava a execução mais lenta. O Selenium 2. 0 possui dois componentes: o sucessor do RC (seu API WebDriver) e o RC próprio (que estava em processo de depreciação). O sucessor foi uma versão largamente implementada do WebDriver, tornando-o uma ferramenta de automação mais potente para web applications. ### Question 5: O mesmo Origem e Sua Manipulação A Política do mesmo Origem (SOP) é conceito de segurança que refere-se à uma web browser permitindo scripts de uma página web a acessar os conteúdos de outra página web apenas se ambas as páginas estiverem no mesmo origem. A origem é uma combinação da URL schema, host e número de porta. Nos modelos anteriores do Selenium, a SOP era uma limitação significativa, tornando difícil a execução de testes em múltiplos servidores e aceder a múltiplas domínias. No entanto isto foi tratado criando o servidor Selenium Remote Control, que enganava o navegador para serem as mesmas domínias do núcleo do Selenium e o aplicativo sob teste. ### Question 6: O que é CELINE's e classificação dela? CELINE's são comandos do Selenium para o Selenium IDE. São comandos que executam o seu teste e são organizados em sequência, formando um script de teste. Estes comandos estão classificados em três categorias principais: 1. **Comandos de Ação**: estes são comandos que alteram o estado da aplicação. Exemplos incluem instruções como clicar em um link ou preencher um formulário. 2. **Comandos de Afirmação**: estes comandos compararam o estado atual da aplicação com o estado esperado. Exemplos incluem comandos para verificar a text, título ou URL de uma página. 3. **Comandos de Controlo**: estes comandos ajudam a navegar dentro do IDE e controlar o fluxo de testes. Exemplos incluem comando para laços, entrada livre de texto e se avaliação. Neste documento, você aprenderá a respeito: 1. **Comandos de Ação** Comandos de ação são, essencialmente, as ações executadas no navegador. São eles: - **Selecione uma opção específica** Abrir um URL Digite determinado texto em uma caixa de entrada Clique ou duplique-clique em algum elemento da web, e assim por diante Estes são conhecidos como **comandos de ação**. 2. **Comandos de Acesso** Comandos de acesso examinam o estado da aplicação, salvando seus resultados em uma variável. Isso lhe permite armazenar determinados valores em uma variável definida pelo usuário, que podem ser usados posteriormente para criar suas afirmações ou verificações no seu teste. - Por exemplo, `store story`, `store text`, `store title` ou `store value`. 3. **Comandos de Verificação** Comandos de verificação são, tecnicamente, como os comandos de acesso, mas eles verificam o estado da aplicação e corroboram com o que foi esperado. Isto é uma comparação de seus resultados atuais com o esperado, e ocorre se o resultado real e o esperado forem iguais. - Existem dois tipos de comandos de verificação: **verificações macias** e **verificações brutas**. - Uma **verificação macia** é conhecida por `verify title`, em que se verifica o título, comparando o título real com o esperado e continuando na execução do teste caso os resultados tenham correspondência. - Já na **verificação bruta**, você executa um comando como `assert title`, e se a afirmação falhar, o teste será interrompido. 4. **Locators na Web** Um locator é uma command que indica ao Selenium qual elemento UI deseja interagir. O Selenium utiliza locators para encontrar e corresponder os elementos da sua página web com os quais ela precisa interagir, e eles têm cerca de 8 técnicas disponíveis na localização. Aqui está uma lista de alguns locating techniques disponíveis no Selenium: - por *ID*: é a técnica de localização mais comum, e comumente utilizada porque eles são supostas serem únicos para cada elemento, a ID pode também ser dinâmica. - para *Link Text* e *Partial Link Text*. Estes locators se aplicam apenas para hiperlinks textuais. Ao dar início, você precisa fornecer o texto completo ou parcial do hiperlink. - por *Nome*, que funciona da mesma forma que localização por ID, mas utiliza um atributo NAME ao invés de ID. - para *Tag Name*, pelo que você pode encontrar todos os elementos da sua página web que possuem uma determinada tag, como um botão. - por *Class Name*, onde os identificadores podem ser utilizados somente se você descobriu que a classe é única para um elemento em sua página web. - por *XPath*, que é um língua necessária quando vai localizando elementos XML, sendo capaz de acessar elementos que não possuem nomes ou IDs específicos. - selecionando pelo CSS: usado para localizar elementos de acordo com o HTML tag, ID, classe ou qualquer outro atributo, e são geralmente mais rápidos que locators como XPath. 5. **Pesos nas WebDriver** Pesos desempenham um papel essencial na execução dos testes na Web, pois a maioria das aplicações na Web são desenvolvidas usando Ajax e JavaScripts, e, ao se carregaruma página pelo navegador, os elementos com os quais você deseja interagir podem cargar durante intervalos de tempo diferentes, o que torna difícil identificá-los e poderá causar que eles lancem a exceção `Element not visible`. Existem três tipos de pesos disponíveis no Selenium: - **Implicit Weight** Implicit Weight diz ao navegador ou ao seu driver da Web esperar um determinado tempo antes de lançar a exceção `Element not found`. - **Explicito Weight** Explicito Weight é usado para informar ao seu driver esperar certas condições antes de lançar a exceção `Element not visible`. Ele é definido para esperar somente para determinadas condições. - **Fluido Weight** Fluido Weight é usado para informar ao seu driver esperar uma condição definida, também com uma frequência definida com o qual queremos carregar o elemento. Dê uma olhada em [aqui](https://www.selenium.dev/documentation/webdriver/ Full documentation#selecting-elements ) para mais informações sobre locators, pesos e como deve implementar o código para cada tipo. **Valor foi posto para demonstrar como o código ficaria. ** # Formatação: - Preserve todos os elementos Markdown (# ** ` [] () etc) - Mantenha a estrutura de títulos e seções - Preserve blocos de código sem traduzir # Tradução: - Use português europeu (não brasileiro) - Mantenha termos técnicos em inglês - Preserve comandos e códigos inalterados - Mantenha URLs intactas # Browser e comandos do Driver: Diferenças entre `browser. quit` e `driver. close` Esta secção fornece uma explicação das diferenças entre os comandos `browser. quit` e `driver. close` no Selenium WebDriver para automação de browsers. ## `driver. close` O comando `driver. close` é utilizado para fechar a janela do browser ativa atual. Se apenas uma janela do browser estiver aberta, a execução deste comando encerrará a sessão inteira do browser. Isto é comum quando se trabalha com múltiplas abas ou janelas do browser e se quer fechar uma específica durante a execução do teste. ``` // Fechar a janela do browser atual driver. close(); ``` ## `browser. quit` O comando `browser. quit` é utilizado para encerrar a sessão inteira do browser, incluindo todas as janelas, abas, pop-ups e tudo o mais. É recomendado usá-lo quando já não se deseja interagir com o objeto do driver e suas janelas, abas e pop-ups. Tipicamente, é uma das últimas instruções do script de automação. ``` // Encerrar a sessão inteira do browser browser. quit(); ``` ## Uso É recomendado utilizar `browser. quit` (ou `driver. quit` em certos casos) quando já não se deseja interagir com o objeto do driver e todas as janelas, abas e pop-ups. Geralmente é uma das últimas instruções de um script de automação, como nos testes em que é frequentemente chamado no método `afterSuite` para encerrar a sessão inteira do browser no final da execução do teste. ## Pergunta 11: Digitar num caixo de texto utilizando Selenium O Selenium fornece o comando `sendKeys` para inserir um valor num caixo de texto. Este comando está disponível como um método num elemento web. Aqui está um exemplo do uso do comando `sendKeys` para inserir um valor num caixo de texto: ``` WebElement fieldEmail = driver. findElement(By. nome("email")); // Encontra o elemento utilizando qualquer um dos oito métodos de localização fieldEmail. sendKeys("seu_email@example. com"); // Envia o valor para o elemento web WebElement fieldPassword = driver. findElement(By. nome("password")); fieldPassword. sendKeys("seu_password"); ``` ## Pergunta 12: Clicar numa ligação num Selenium O Selenium oferece duas técnicas de localização para ligações: `linkText` e `partialLinkText`. ### Texto da ligação Utilizando o texto da ligação, fornece o texto completo da ligação para a identificação. Por exemplo, se tiver uma ligação numa página de Amazon com o texto " Promoções do Dia ", pode utilizar o seguinte código para clicar nelas: ``` WebElement linkPromocoes = driver. findElement(By. texto("Promoções do Dia")); linkPromocoes. click(); ``` ### Texto parcial da ligação Se quiser usar apenas uma parte do texto para a técnica de localização, pode utilizar o método `partialLinkText`. Por exemplo, se o texto da ligação for longo, e não quiser usar todo o texto para a identificação, pode utilizar o seguinte código: ``` WebElement linkServleticio = driver. findElement(By. partialText("Serviço")); linkServleticio. click(); ``` ## Pergunta 13: Deslocar para baixo numa página utilizando JavaScript Em certos casos, poderá necessitar de deslocar para baixo numa página utilizando JavaScript para executar certas funções ou para identificar elementos que não estão visíveis utilizando as técnicas de localização fornecidas pelo Selenium. O Selenium fornece uma interface JavaScript Executor que pode ajudá-lo a executar JavaScript na janela selecionada ou na página atual. Aqui está um exemplo de deslocar para baixo numa página verticalmente utilizando JavaScript: ``` JavascriptExecutor js = (JavascriptExecutor) driver; js. executeScript("window. scrollBy(0, 1000); "); ``` ## Pergunta 14: Aserção do título de uma página web Pode utilizar o método `getTitle` oferecido pelo WebDriver para recuperar o título da página atual e verificá-lo contra um título esperado. Aqui está um exemplo de recuperação do título de uma página web e da verificação contra um título esperado: ``` String tituloActual = driver. getTitle(); String tituloEsperado = "Título Esperado"; if (tituloActual. equals(tituloEsperado)) { System. out. println("Verificação do título passada. "); } else { System. out. println("Verificação do título falhou. Esperado: " + tituloEsperado + ". Real: " + tituloActual); } ``` ## Pergunta 15: Ajaçar o apontador do rato num elemento em automação Para realizar uma ação num elemento que fica visível apenas ao passar o rato em cima do mesmo, pode utilizar a classe `Actions`. Esta classe está definida no pacote `selenium. interactions` e tem uma rica coleção de API para emular gestos do utilizador. Aqui está um exemplo de mover o apontador do rato para um elemento utilizando a classe `Actions`: ``` Actions action = new Actions(driver); WebElement elementoHover = driver. findElement(By. id("elementId")); action. moveToElement(elementoHover). perform(); ``` ## Pergunta 16: Como fechar o browser após o final da execução do teste Para fechar o browser no final da execução do teste, pode utilizar either `browser. quit` ou `driver. quit` de acordo com a convenção de nomenclatura utilizada no seu projeto. Este é frequentemente feito no método `afterSuite` da sua test suite para encerra a sessão inteira do browser no final da execução dos testes. Por exemplo: ``` @AfterSuite public void closeBrowser() { driver. quit(); } ``` # Recuperação de Propriedades CSS usando getCSSValue em Selenium (Português de Portugal) O Modelo de Página (POT) é um padrão de projeto que ajuda a criar repositórios de elementos de interface. Isso garante a manutenibilidade, legibilidade e reutilização do código ao escrever casos de teste de Selenium. ## Recuperação de Propriedades CSS Para recuperar as propriedades CSS de um elemento, precisamos usar um método especial chamado `getCSSValue`. Este método é essencial porque o método `getAttribute` só pode recuperar propriedades onde os atributos e seus valores estão mencionados no DOM. Alguns atributos, como tamanho de fonte e cor, não podem ser recuperados pelo método `getAttribute`. Aqui está um exemplo do método `getCSSValue` para recuperar o tamanho de uma caixa de entrada de e-mail: ```java // Encontra a caixa de entrada de e-mail usando seu ID WebElement emailField = driver. findElement(By. id("email-input-id")); // Use getCSSValue para recuperar o tamanho da fonte String fontSize = emailField. getCssValue("font-size"); System. out. println("Tamanho de fonte: " + fontSize); ``` Neste exemplo, estamos usando o método `getCssValue` para recuperar o tamanho de fonte de uma caixa de entrada de e-mail com o ID "email-input-id". O tamanho de fonte é depois impresso no console. ## Modelo de Página Model (POT) O Modelo de Página (POT) ajuda a criar repositórios de elementos de interface para cada página em uma aplicação. Cada página da aplicação deve ter uma correspondente classe de página, contendo elementos de interface e métodos da página. Os casos de teste usando métodos da classe da página podem interagir com a interface da página. As vantagens de usar POT incluem: - Manutenibilidade do código: Se a interface da página for alterada, o teste não precisará ser alterado; apenas o código dentro da classe da página precisará ser atualizado. - Legibilidade do código: O POT torna o código mais lerável e compreensível. - Reutilização do código: Os métodos da página estão separados, permitindo que sejam reutilizados em vários casos de teste para a mesma página. ## Gestão de molduras de Pop-ups baseadas em Janela O Selenium é uma ferramenta de automatização de aplicativos web e não manipula molduras de aplicativos baseadas em janelas. Ferramentas como o AutoIt e a classe Robot podem ser utilizadas em conjunto com o Selenium para manipular tais molduras de pop-up. - Classe Robot: A Classe Robot, uma classe Java junto com o Selenium, pode simular eventos de teclado e mouse, auxiliar na transferência de ficheiros e gerir molduras pop-up. - AutoIt: AutoIt é um software livre que utiliza a combinação de seus movimentos de rato, teclas de teclado e manipulação de controles da janela para automatizar qualquer tarefa que não é possível por Selenium drivers web. O AutoIt integra-se com o Selenium, permitindo que humorizemos molduras de pop-up nativas. ## Tomando capturas de ecrã com o WebDriver O Selenium fornece o `TakeScreenshot` interface para gerir operações de capturar de ecrã. Esta funcionalidade é útil para depuração de casos de teste e para identificar problemas durante a execução do teste. Para tomar uma captura de ecrã, use o método `getScreenshotAs` proporcionado na interface `TakeScreenshot`: ```java // Toma uma captura de ecrã quando um teste falha File screenshot = ((TakesScreenshot) driver). getScreenshotAs(OutputType. FILE); ``` Aqui, estamos usando o método `getScreenshotAs` para tomar uma captura de ecrã quando um teste falha. A captura de ecrã é guardada como um objeto `File`. É possível especificar a localização e o nome do ficheiro para a captura de ecrã. ## Usando o Executor JavaScript para escrever em uma caixa de texto Em vez de usar o método `sendKeys`, pode ser usada a execução JavaScript para simular a entrada de texto numa caixa de texto. Aqui está um exemplo: ```java // Identifica a caixa de texto de e-mail usando seu id WebElement emailField = driver. findElement(By. id("email-input-id")); // Escreve o valor de e-mail usando o Executor JavaScript JavascriptExecutor executor = (JavascriptExecutor) driver; executor. executeScript("argument[0]. value='" + email + "'; ", emailField); ``` Neste exemplo, estamos usando o Executor JavaScript para definir o valor da caixa de texto de e-mail identificada pelo seu id. Passamos o valor de e-mail como um argumento para a função JavaScript. Isso reproduz o efeito de introduzir o valor de e-mail na caixa de texto. # Guia Técnico: Programa Java, WebDriver de Selenium e Gerenciamento de Janela do Navegador Neste guia, exploraremos um programa Java específico utilizando o JavaScript executor e o WebDriver de Selenium para realizar determinadas operações dentro de uma aplicação Facebook. A nossa focus será no uso de `select` objects e `switch to` comandos para interagir com listas de opções dropdown e janelas multiplas, respectivamente, além de lidar com uploads de ficheiros, definir tamanhos de janela do navegador e encontrar elementos. ## Programa Java com JavaScript Executor Esse capitulo detalha os passos para executar um programa Java utilizando o JavaScript executor para recriar o método `sendKeys()` e seleccionar um elemento de uma lista dropdown dentro do WebDriver de Selenium. ### Seleccionar um valor da sua lista de dropdown no WebDriver de Selenium No WebDriver de Selenium, utilizamos a `select` class para seleccionar e deseleccionar opções nas listas dropdown. Esses `select` objects podem ser instanciados passando um elemento web dropdown como parâmetro ao seu construtor. Exemplo: ```markdown // Identificar o elemento web dropdown para a seleção da data WebElement dropdown = driver. findElement(By. id("date-dropdown")); // Inicializar a instância Select do dropdown Select dateSelection = new Select(dropdown); // Utilizar os métodos seleccionar para seleccionar um item da lista dropdown int dayIndex = 9; // Seleccionar o dia 10 na lista dropdown devido ao índice ser zero-based dateSelection. selectByIndex(dayIndex); // Seleccionar o mês (Junho) utilizando o seu próprio índice int monthIndex = 5; // Os meses estão em inglês e a contagem do índice começa com 0 dateSelection. selectByIndex(monthIndex); // Seleccionar o ano (2005) utilizando o seu texto visible dateSelection. selectByVisibleText("2005"); ``` ## Comandos `switch to` O comando `switch to` é utilizado para alternar entre janelas, quadros ou até mesmo alertas de caixa de diálogo dentro da sua aplicação. Em geral é utilizado para gerir diferentes janelas ou quadros na sua aplicação web. ### Carregar um ficheiro no WebDriver de Selenium Há duas formas de realizar uma operação de carregamento de ficheiros no WebDriver de Selenium: através do método `sendKeys()` e através da classe Robot. - Utilizando o `sendKeys()`, tem de introduzir o nome completo do arquivo junto com o caminho dele, se o elemento possui o "input" tag com o 'type' definido para "file". Exemplo: ```java File file = new File("caminho/para/seuarquivo. txt"); driver. findElement(By. id("file-upload")). sendKeys(file. getAbsolutePath()); ``` - Utilizando a classe Java `Robot`, gerimos o diálogo de seleção de ficheiros utilizando comandos que simulam certas ações para seleccionar um posterior arquivo em concreto do diálogo. É usado quando o botão de carregamento clicável abre uma janela nova contendo o explorador de ficheiros nativo. Example: Neste caso, você utiliza a classe Java `Robot` para simular as necessárias ações de seleção do arquivo. A implementação varia de acordo com os sistemas operativos e é um pouco complexa, portanto, não incluímos um exemplo aqui. ### Aumentar o Tamanho da janela de navegador no WebDriver Para maximizar ou definir um tamanho específico para a janela de navegador, pode utilizar as funções `driver. manage()`. Para maximizar a janela: ```java driver. manage(). window(). maximize(); ``` Para definir um tamanho específico para janela de navegador (e. g. , width=800 e height=600): ```java Dimension dimension = new Dimension(800, 600); driver. manage(). window(). setSize(dimension); ``` ### Localizar Elementos no WebDriver Utilize o método `findElement()` para aceder a um elemento web único, e o método `findElements()` para devolver uma lista de elementos web. Exemplo: ```java List<WebElement> elements = driver. findElements(By. className("text-input")); ``` Neste exemplo, todos os elementos web com a classe começando com "text-input" serão devolvidos na lista. Pode então utilizar todos os elementos individualmente através de seu índice ou de outras critérias relevantes. Para mais informações sobre o WebDriver de Selenium e o programação Java com ele, recomendamos os seguintes recursos: * Documentação oficial do WebDriver de Selenium: https://www.selenium.dev/documentation/ * Um livro do WebDriver de Selenium Java por Filip Pacourek: https://www.filip-pacourek.eu/selenium-java-essentials-guide/ # Documentação ## 1. Localizando Elementos com Classe Começando por "input" no Selenium WebDriver usando XPath Nesta seção, aprenderemos a localizar elementos com uma classe que começa por "input" no Selenium WebDriver usando XPath. ### Expressão XPath A expressão XPath usada neste exemplo é: ``` //*[starts-with(@class, 'input')] ``` ### Código Aqui está um example simples demonstrando o uso de XPath para localizar elementos com uma classe que começa por "input". ```java import org. openqa. selenium. By; import org. openqa. selenium. WebDriver; import org. openqa. selenium. WebElement; import org. openqa. selenium. firefox. FirefoxDriver; public class LocalizarElementos { public static void main(String[] args) { // Inicializa o WebDriver WebDriver driver = new FirefoxDriver(); // Navega para a página do Facebook driver. get("https://www.facebook.com"); // Defina a expressão XPath String xPathExpression = "//*[starts-with(@class, 'input')]"; // Encontra todos os elementos que correspondem à expressão XPath WebElementList elements = driver. findElements(By. xpath(xPathExpression)); // Armazena os elementos encontrados em um array de lista List<WebElement> elementsList = new ArrayList<WebElement>(elements); // Percorra o array usando um laço "for enhanced" for (WebElement element : elementsList) { // Imprima o atributo 'id' de cada elemento System. out. println(element. getAttribute("id")); } // Feche o WebDriver driver. quit(); } } ``` ## 2. Pausar em Excessão no Selenium WebDriver Pausar em Excessão é uma característica do Selenium IDE que permite que a execução de seus testes seja pausada se qualquer excessão ocorrer. Nesta seção, aprenderemos a usar a funcionalidade Pausar em Excessão no Selenium WebDriver. ### Exemplo Neste exemplo, demonstraremos o uso da funcionalidade Pausar em Excessão por meio da fornecimento de um id errado para o campo de senha no teste de login do Facebook. ```java import org. openqa. selenium. By; import org. openqa. selenium. WebDriver; import org. openqa. selenium. WebElement; import org. openqa. selenium. firefox. FirefoxDriver; public class PausarEmExcessao { public static void main(String[] args) { // Inicializa o WebDriver WebDriver driver = new FirefoxDriver(); // Navega para a página do Facebook driver. get("https://www.facebook.com"); // Encontra o campo de email e insira o email WebElement campoDeEmail = driver. findElement(By. name("email")); campoDeEmail. sendKeys("seu_email@exemplo. com"); // Encontra o campo de senha com um id errado (intencional) WebElement campoDeSenha = driver. findElement(By. id("id_errado")); campoDeSenha. sendKeys("senha_seu"); // Encontra o botão de login e clique nesse botão WebElement botaoDeLogin = driver. findElement(By. name("login")); botaoDeLogin. click(); // Habilite o Pausar em Excessão // Note: O método para habilitar o Pausar em Excessão pode variar de acordo com a versão do Selenium WebDriver que está a usar. // Aqui tem um example com o FirefoxDriver: ((FirefoxDriver) driver). manage(). executeScript("selenium. browserbot. getCurrentWindow(). selenium. setDebug(true); "); // Executa o teste driver. executeScript("runTest(); "); // Feche o WebDriver driver. quit(); } } ``` Quando executar este teste, a execução será suspensa em momento em que o id errado é fornecido para o campo de senha, permitindo-lhe tratar a error e retomar a execução do teste. ## 3. Logar numa página com Pop-up de Autenticação Nesta seção, aprenderemos a tratar de um pop-up de autenticação no Selenium WebDriver. ### Exemplo Neste example, demonstraremos como lidar com um Pop-up de Autenticação ao navegar para a página da específica. ```java import org. openqa. selenium. By; import org. openqa. selenium. WebDriver; import org. openqa. selenium. WebElement; import org. openqa. selenium. firefox. FirefoxDriver; public class LoginPáginaComPopUpAutenticação { public static void main(String[] args) { // Inicializa o WebDriver WebDriver driver = new FirefoxDriver(); // Navega para a página que exige autenticação driver. get("URL_DA_PÁGINA_QUE_EXIGE_AUTENTICAÇÃO"); // Encontra o elemento de login e clique nesse elemento WebElement elementoDeLogin = driver. findElement(By. name("nome_do_elemento_de_login")); elementoDeLogin. click(); // Navega para a janela de autenticação WebElement elementoDeJanela = driver. findElement(By. name("nome_do_elemento_de_janela")); ((JavascriptExecutor) driver). executeScript("window. location = arguments[0]", elementoDeJanela. getAttribute("value")); // Procura elemento do login WebElement campoDeLogin = driver. findElement(By. name("nome_do_campo_de_login")); campoDeLogin. sendKeys("seu_login"); // Procura o elemento do password WebElement campoDePassword = driver. findElement(By. name("nome_do_campo_de_password")); campoDePassword. sendKeys("senha_seu"); // Encontra o botão de autenticação e clique no botão de autenticação WebElement botaoDeAutenticação = driver. findElement(By. name("nome_do_botao_de_autenticação")); botaoDeAutenticação. click(); // Feche o WebDriver driver. quit(); } } ``` Siga os passos acima para testar a autenticação em uma página que exigir autenticação. Aprenda mais sobre a funcionalidade do FirefoxDriver [aqui](https://mozilla.github.io/geckodriver/). # Tutorial de Automação de Testes Este tutorial aborda os fundamentos da automação, centrando-se em o que deve ser automatizado, o que não deve e o esforço necessário para automatizar. ## Básico da Automação A automação é definida como a redução do esforço humano em tarefas. Seu objetivo é reduzir tarefas repetitivas e economizar tempo, especialmente para casos de regressão. É importante lembrar que a automação deve ser empregada de maneira cuidadosa. O esforço que se salva deve ser valorizado o suficiente para o tempo que é gasto para automatizar, e ele não deve levantar esforços se a solução automatizada não for utilizada no futuro. ## Automação de Testes de Software A automação de testes de software refere-se às atividades e esforços que automatizam tarefas manualmente executadas em um processo de teste de software usando estrategias e soluções sistemáticas bem definidas. Isso envolve a criação de scripts de teste, os quais então são executados. ### DevOps e Automação de Testes A DevOps e a automação de testes estão intimamente relacionados. A DevOps é uma equipe responsável por automatizar os processos de desenvolvimento e implantação de software. Embora não vamos abarcar o assunto DevOps de forma profunda, é importante notar que o Selenium é uma componente da DevOps e pode ajudar a melhorar o feedback, a cobertura de testes e reduzir o custo da qualidade. ### Automação de Testes em Ambientes Agile Em um ambiente Agile, a automação pode ajudar as equipes a alcançar a agilidade permitindo lançamentos e implantações frequentes. Ele oferece monitoramento, integração e teste contínuos. Com automação, as equipes podem rapidamente identificar e corrigir problemas quando novo código é introduzido, garantindo que as mudanças não quebram no ambiente de produção. ## Tutorial Básico de Appium O Appium é uma ferramenta open-source utilizada para automatizar aplicativos móveis. Ele funciona através da interação com o Selenium e o automatizador de interface UI (para Android) ou do XCUITest gerenciado por Apple (para iOS). Ele pode automatizar aplicativos nativos, web e híbridos, tornando-o uma ferramenta essencial para o teste de aplicativos móveis no mundo atual, em que o app-centric é comum. O Appium suporta várias línguas e plataformas, permitindo escrever testes para dispositivos Android, Windows e iOS. Ele também suporta execução em dispositivos reais e em simuladores, assegurando cobertura de testes completa. Os soluções multiplataforma no Appium não estão relacionadas ao sistema de operação do dispositivo móvel, tornando-o uma ferramenta versátil para o teste de aplicativos móveis. --- URLs: - [Tutorial de Automação de Testes](https://www.youtube.com/watch?v=OvN1bi3u8XI) - [Tutorial Básico de Appium para Iniciantes](https://www.youtube.com/watch?v=g6tCIvdk6-I) Idioma: Inglês [Música] Este tutorial explica a importância da automação de testes no fechamento da brecha entre as expectativas dos usuários e a velocidade do desenvolvimento. Ele foca na Appium, uma ferramenta utilizada para automatizar aplicativos móveis, e como ela interage com o Selenium e o automatizador UI apropriado para dispositivos Android ou iOS. Appium suporta várias plataformas, sem distinção ao sistema de operação do dispositivo móvel. Ele também permite a execução em dispositivos reais e em simuladores, garantindo cobertura de testes completa. As soluções multiplataforma no Appium são lingua-não-específicas, tornando-o uma ferramenta versátil para o teste de aplicativos móveis. # Filosofia de Automação de Testes para RPM para Múltiplas Plataformas ## Visão Geral O RPM aproveita os fluxos de automação de teste fornecidos pelos fornecedores para a automação de teste sem necessidade de compilação de aplicativos. Isso garante testar a mesma aplicação, sem alterações, em três plataformas diferentes - Android, iOS e Windows. ### Destacadas - O RPM utiliza APIs Selenium WebDriver para todas as suas frameworks, incluindo o protocolo JSON WireProtocol de comunicação cliente-servidor. - Você pode utilizar quaisquer bibliotecas de cliente para escrever seus testes de caso, e qualquer framework SD, como JUnit, é bem-vindo. - O RPM estende o WebDriver 1 e fornece APIs adicionais específicas para automação de testes móveis. - Usando RPM ao lado de Appium Live Ready prevê classes e métodos específicos para automação de testes, como a funcionalidade de deslizamento e tocar no dispositivo. ### Componentes do RPM #### Servidor O servidor RPM é implementado com Node. js e recebe scripts de teste executados através de solicitações HTTP usando o protocolo JSON Wire Protocol. De forma transparente, ele pode usar traços do Selenium Grid ou Selenium RC Remote Control para converter ordens de teclado em ordens aceitáveis por dispositivos móveis. #### UI Automator (Android) O Automator de UI do Google é a ferramenta utilizada pelo RPM para testes funcionais de UI cruz-app para aplicativos Android. Ele é uma biblioteca Java contendo uma bilheteira leve de APIs para construção de testes de UI e interação com os elementos em aplicativos do usuário e aplicativos do sistema. ### Instalação 1. Baixe e instale o SDK Android, que inclui o Visualizador de UI Automator. 2. Conecte o seu dispositivo ou crie um simulador para trabalhar com o Visualizador de UI Automator. 3. Use o Visualizador de UI Automator para localizar locadores de elementos, obter o estado da aplicação e performance nas aplicações em um dispositivo, e fornecer suporte a interfaces UI cruz-app no Android SDK. ### CAPABILIDADES DESIDERADAS Ao trabalhar com Android, você precisa: - Baixar o SDK Android com o Android Studio para escrever seu código. - Aprender a criar simuladores com configurações específicas. - Iniciar o servidor Appium, selecione o arquivo APK do Android e aprender sobre o localização de detalhes do arquivo APK. - Usar o Visualizador de UI Automator para localizar elementos e começar a escrever seu script. ### Tutorial Selenium IDE para Iniciantes Quer aprender Selenium IDE? Verifique nossa detalhada série de vídeos a seguir: [Tutorial Selenium IDE para Iniciantes | Selenium IDE Installation | Selenium Training | Simplilearn](https://www.youtube.com/watch?v=TdB9-Kda26w) (Inglês, [Música]) Este tutorial aborda as funcionalidades do Selenium IDE, incluindo a localização automática de elementos usando selectores como ID, nome, link, XPath, e CSS. Você também aprenderá sobre a seleção de comandos de Selenium pelo painel de listagem deslizante e soluções de depuração de testes. Adicionalmente, você descobrirá como salvar testes em HTML e converter os arquivos em webdriver, e suporte para arquivos de extensões de usuário Selenium . js. Assim, dê uma olhada e comece sua jornada com o Selenium IDE hoje! # Tabela de Conteúdos 1. [Introdução](#introdução) 2. [Guia: Descarregue & Instale o Selenium](#guia) 3. [Perguntas Frequentemente Poriguntadas sobre o Selenium e Respostas](#perguntas-frequentemente-poriguntadas) --- ## <a id="introdução"></a>Introdução Este guia fornecerá um processo passo a passo sobre como descarregar e instalar o WebDriver do Selenium. Se você gostar deste vídeo, inscreva-se no [Canal do YouTube](https://www.youtube.com/channel/UCw3yourb_XZX48_TnXfv2EA) e clique ao seguir para assistir a vídeos semelhantes sobre a automação do Selenium e para se certificar. --- ## <a id="guia"></a>Guia: Descarregue & Instale o Selenium | Setup do WebDriver do Selenium | Guia de Instalação do Selenium | Simplilearn Para descarregar e instalar o Selenium, siga estes passos: 1. Abra o seu navegador de internet preferido (por exemplo, Firefox, Chrome ou Edge). 2. Navegue até o site oficial do [Selenium](http://www.seleniumhq.org/download/). 3. Clique no versão mais recente e estável do WebDriver do Selenium compatível com sua plataforma (Windows, Mac ou Linux). 4. Faça o download do arquivo executável para sua operação sistema. 5. Quando o download for concluído, localize o arquivo executável e clique nele duas vezes para iniciar o processo de instalação. 6. Siga as instruções de instalação fornecidas. 7. Após a instalação bem-sucedida, verifique se o WebDriver do Selenium foi adicionado à variável PATH do sistema. * No Windows, você pode verificar isso abrindo um Prompt de Comando e digitando `java -jar selenium-server-standalone. jar` sem erros. * No Linux, você pode verificar isso abrindo o Terminal e digitando `java -jar selenium-server-standalone. jar` sem erros. --- ## <a id="perguntas-frequentemente-poriguntadas"></a>Perguntas Frequentemente Poriguntadas sobre o Selenium e Respostas | Tutorial do Selenium | Treinamento do Selenium | Simplilearn lang: en [Música] [Música] [Música] [Música] Se estiver a preparar-se para uma entrevista do Selenium, talvez encontre estas perguntas frequentemente poriguntadas: 1. **O que é Selenium? ** O Selenium é uma plataforma de teste de aplicações web aberta-fonte principalmente projetada para a automação de testes. 2. **Por que usar o Selenium para testar aplicações web? ** O Selenium permite aos desenvolvedores e testadores a criação de testes automatizados que são eficientes, precisos e confiáveis. Por automatizar tarefas repetitivas, ele economiza tempo, melhora a qualidade do código e aumenta a produtividade. 3. **Que componentes compõem o Selenium? ** O Selenium é composto por quatro componentes principais: - Ambiente Integrado de Desenvolvimento do Selenium (IDE) - WebDriver do Selenium - Selenium Grid - Selenium Remote Control (RC) 4. **Quais os idiomas de programação podem ser utilizados com o WebDriver do Selenium? ** O WebDriver do Selenium permite o uso de vários idiomas de programação, incluindo Java, C#, Ruby, Python, PHP e JavaScript. 5. **O que são os benefícios do uso do Selenium Grid? ** O Selenium Grid melhora a escalabilidade da execução de testes permitindo testar em paralelo em vários navegadores e sistemas operacionais. Isto reduz significantemente o tempo de execução de testes e amplia a cobertura das situações de teste. 