portaldacalheta.pt
  • Principal
  • Receita E Crescimento
  • Aprendendo
  • Processo Interno
  • Processo De Design
Tecnologia

Automação no Selenium: Modelo de objeto de página e fábrica de página



Escrever testes automatizados é mais do que apenas um luxo para qualquer equipe ágil de desenvolvimento de software. É uma necessidade e uma ferramenta essencial para localizar bugs rapidamente durante as fases iniciais dos ciclos de desenvolvimento de software. Quando há um novo recurso que ainda está em fase de desenvolvimento, os desenvolvedores podem executar testes automatizados e ver como outras partes do sistema são afetadas por essas mudanças. Este artigo explicará como você pode acelerar o teste automatizado usando o modelo de objeto de página em Selênio .

Através automação de teste , é possível reduzir o custo da correção de bugs e trazer melhorias gerais para o garantia de qualidade de software (QA). Com testes adequados, os desenvolvedores têm a chance de encontrar e resolver bugs antes mesmo que cheguem ao controle de qualidade. A automação de teste nos ajuda ainda mais a automatizar casos de teste e recursos que estão em constante regressão. Dessa forma, os QAs têm mais tempo para testar outras partes do aplicativo. Além disso, auxilia na garantia da qualidade do produto nos lançamentos de produção. Como resultado, obtemos produtos que são efetivamente mais estáveis ​​e um processo de controle de qualidade mais eficiente.



A automação do Selenium simplifica a automação de teste para aplicativos da web



Selenium simplifica a automação de teste para aplicativos da web Tweet

Embora escrever testes automatizados possa parecer uma tarefa fácil para desenvolvedores e engenheiros, ainda existe a possibilidade de acabar com testes mal implementados e com o alto custo de manutenção de código em qualquer processo ágil. Tentar entregar constantemente mudanças ou recursos em qualquer projeto de desenvolvimento ágil pode ser caro quando os testes estão envolvidos. Alterar um elemento em uma página da web da qual dependem 20 testes exigirá que uma pessoa passe por essas 20 rotinas de teste e atualize cada uma para se adaptar a essa mudança recém-introduzida. Isso pode não apenas ser muito demorado, mas também um fator de desmotivação sério quando se trata de implementar testes automatizados desde o início.



Mas, e se pudéssemos fazer a mudança em apenas um lugar e fazer com que todas as rotinas de teste relevantes a usassem? Neste artigo, daremos uma olhada nos testes automatizados no Selenium e como podemos usar modelos de objeto de página para escrever rotinas de teste sustentáveis ​​e reutilizáveis.

Modelo de objeto de página no Selenium

Modelo de objeto de página é um padrão de design de objeto no Selenium, onde as páginas da web são representadas como classes e os vários elementos na página são definidos como variáveis ​​na classe. Todas as possíveis interações do usuário podem ser implementadas como métodos na classe:



clickLoginButton(); setCredentials(user_name,user_password);

Como métodos bem nomeados em classes são fáceis de ler, isso funciona como uma maneira elegante de implementar rotinas de teste que são legíveis e fáceis de manter ou atualizar no futuro. Por exemplo:

Para oferecer suporte ao modelo de objeto de página, usamos Fábrica de Páginas . O Page Factory no Selenium é uma extensão do Page Object e pode ser usado de várias maneiras. Nesse caso, usaremos o Page Factory para inicializar os elementos da web que são definidos nas classes de página da web ou nos objetos de página.



As classes de página da web ou objetos de página contendo elementos da web precisam ser inicializados usando o Page Factory antes que as variáveis ​​do elemento da web possam ser utilizadas. Isso pode ser feito simplesmente com o uso de initElements função na PageFactory:

como obter informações do cartão de crédito de alguém
LoginPage page = new LoginPage(driver); PageFactory.initElements(driver, page);

Ou ainda mais simples:



LoginPage page = PageFactory.intElements(driver,LoginPage.class)

Ou, dentro do construtor de classe da página da web:

public LoginPage(WebDriver driver) { this.driver = driver; PageFactory.initElements(driver, this); }

O Page Factory irá inicializar a cada WebElement variável com uma referência a um elemento correspondente na página da web real com base em “localizadores” configurados. Isso é feito através do uso de @FindBy anotações. Com esta anotação, podemos definir uma estratégia para procurar o elemento, juntamente com as informações necessárias para identificá-lo:



@FindBy(how=How.NAME, using='username') private WebElement user_name;

Cada vez que um método é chamado neste WebElement variável, o driver irá primeiro encontrá-la na página atual e então simular a interação. Caso estejamos trabalhando com uma página simples, sabemos que encontraremos o elemento na página toda vez que a procurarmos, e também sabemos que eventualmente navegaremos para fora desta página e não retornaremos a ela, podemos armazenar em cache o campo pesquisado usando outra anotação simples:

@FindBy(how=How.NAME, using='username') @CacheLookup private WebElement user_name;

Toda esta definição da variável WebElement pode ser substituída por sua forma muito mais concisa:



@FindBy(name='username') private WebElement user_name;

o @FindBy a anotação oferece suporte a várias outras estratégias que tornam as coisas um pouco mais fáceis:

id, name, className, css, tagName, linkText, partialLinkText, xpath @FindBy(id='username') private WebElement user_name; @FindBy(name='passsword') private WebElement user_password; @FindBy(className='h3') private WebElement label; @FindBy(css=”#content”) private WebElement text;

Depois de inicializadas, essas variáveis ​​WebElement podem ser usadas para interagir com os elementos correspondentes na página. O código a seguir irá, por exemplo:

user_password.sendKeys(password);

… Envia a sequência de pressionamentos de tecla fornecida para o campo de senha na página e é equivalente a:

driver.findElement(By.name(“user_password”)).sendKeys(password);

Continuando, você frequentemente se deparará com situações em que precisa encontrar uma lista de elementos em uma página, e é quando @FindBys vem a calhar:

@FindBys(@FindBy(css=”div[class=’yt-lockup-tile yt-lockup-video’]”))) private List videoElements;

O código acima encontrará todos os div elementos com dois nomes de classe “yt-lockup-tile” e “yt-lockup-video”. Podemos simplificar ainda mais substituindo-o pelo seguinte:

@FindBy(how=How.CSS,using='div[class=’yt-lockup-tile yt-lockup-video’]') private List videoElements;

Além disso, você pode usar @Encontrar tudo com múltiplos @FindBy anotações para procurar elementos que correspondam a qualquer um dos localizadores fornecidos:

@FindAll({@FindBy(how=How.ID, using=”username”), @FindBy(className=”username-field”)}) private WebElement user_name;

Agora que podemos representar páginas da web como classes Java e usar o Page Factory para inicializar WebElement variáveis ​​facilmente, é hora de vermos como podemos escrever testes Selenium simples usando o padrão Page Object e Page Factory.

como programar c ++

Projeto de automação de teste simples do Selenium em Java

Para nosso tutorial de modelo de objeto de página, vamos automatizar a inscrição do desenvolvedor no ApeeScape. Para fazer isso, precisamos automatizar as seguintes etapas:

  • Visite www.toptal.com

  • Clique no botão “Aplicar como desenvolvedor”

  • Na página do portal, verifique primeiro se ele está aberto

  • Clique no botão “Entrar no ApeeScape”

  • Preencha o formulário

  • Envie o formulário clicando no botão “Entrar no ApeeScape”

Configurando um Projeto

  • Baixar e instalar Java JDK

  • Baixar e instalar InteliJ Idea

  • Crie um novo projeto Maven

    como testar seu código
  • Vincule “SDK do projeto” ao seu JDK, por exemplo: no Windows “C: Arquivos de programas Java jdkxxx”

  • Configure groupId e artifactId:

SeleniumTEST Test
  • Adicione dependências Selenium e JUnit Maven no arquivo POM do seu projeto
junit junit ${junit.version} test org.seleniumhq.selenium selenium-firefox-driver ${selenium.version} org.seleniumhq.selenium selenium-support ${selenium.version} org.seleniumhq.selenium selenium-java ${selenium.version}

Substitua a versão do Selenium e a versão do JUnit pelos números da versão mais recente que podem ser encontrados pesquisando por JUnit Maven no Google e no site do Selenium.

Nesse ponto, se a compilação automática estiver habilitada, o download das dependências deve ser iniciado automaticamente. Do contrário, basta ativar Plugins> instalar> instalar: instalar no painel Projetos Maven no lado direito do seu IDE IntelliJ Idea.

Captura de tela do IDE do tutorial de teste de selênio

Uma vez que o projeto foi inicializado, podemos começar a criar nosso pacote de teste em “src / test / java”. Nomeie o pacote como “com.toptal” e crie mais dois pacotes sob ele: “com.toptal.webpages” e “com.toptal.tests”.

captura de tela do tutorial de teste de selênio

o que torna uma boa api

Manteremos nossas classes de objeto de página / fábrica de página em “com.toptal.webpages” e as rotinas de teste em “com.toptal.tests”.

Agora, podemos começar a criar nossas classes de objeto de página.

Objeto da página inicial

O primeiro que precisamos implementar é para a página inicial do ApeeScape (www.toptal.com). Crie uma classe em “com.toptal.webpages” e nomeie-a “HomePage”.

package com.toptal.webpages; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.support.FindBy; import org.openqa.selenium.support.How; import org.openqa.selenium.support.PageFactory; public class HomePage { private WebDriver driver; //Page URL private static String PAGE_URL='https://www.toptal.com'; //Locators //Apply as Developer Button @FindBy(how = How.LINK_TEXT, using = 'APPLY AS A DEVELOPER') private WebElement developerApplyButton; //Constructor public HomePage(WebDriver driver){ this.driver=driver; driver.get(PAGE_URL); //Initialise Elements PageFactory.initElements(driver, this); } public void clickOnDeveloperApplyButton(){ developerApplyButton.click(); } }

Determinando Localizadores de Elementos

Na página inicial do ApeeScape, estamos interessados ​​em um elemento em particular, que é o botão “Aplicar como desenvolvedor”. Podemos encontrar esse elemento combinando o texto, que é o que estamos fazendo acima. Ao modelar páginas da web como classes de objeto de página, localizar e identificar elementos pode frequentemente se tornar uma tarefa árdua. Com as ferramentas de depuração do Google Chrome ou Firefox, isso pode ser facilitado. Ao clicar com o botão direito em qualquer elemento em uma página, você pode ativar a opção “Inspecionar elemento” no menu de contexto para descobrir informações detalhadas sobre o elemento.

Uma maneira comum (e minha preferida) é encontrar elementos usando o Firefox Extensão FireBug , em combinação com o driver da Web do Firefox no Selenium. Depois de instalar e habilitar a extensão FireBug, você pode clicar com o botão direito na página e selecionar “Inspecionar elemento com FireBug” para abrir o FireBug. Na guia HTML do FireBug, você pode copiar o XPath, Caminho CSS, nome da tag ou “Id” (se disponível) de qualquer elemento na página.

modelo de objeto de página em selênio: determinando localizadores de elemento

Copiando o XPath do elemento na captura de tela acima, podemos criar um campo WebElement para ele em nosso objeto de página da seguinte maneira:

@FindBy(xpath = '/html/body/div[1]/div/div/header/div/h1') WebElement heading;

Ou para manter as coisas simples, podemos usar o nome da tag 'h1' aqui, desde que identifique exclusivamente o elemento em que estamos interessados:

@FindBy(tagName = 'h1') WebElement heading;

DeveloperPortalPage Page Object

Em seguida, precisamos de um Objeto de Página que represente a página do portal do desenvolvedor, que podemos alcançar clicando no botão “Aplicar como Desenvolvedor”.

Nesta página, temos dois elementos de interesse. Para determinar se a página foi carregada, queremos verificar a existência do título. E também queremos um WebElement campo para o botão “Join ApeeScape”.

package com.toptal.webpages; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.support.FindBy; import org.openqa.selenium.support.PageFactory; public class DeveloperPortalPage { private WebDriver driver; @FindBy(xpath = '/html/body/div[1]/div/div/header/div/h1') private WebElement heading; @FindBy(linkText = 'JOIN TOPTAL') private WebElement joinApeeScapeButton; //Constructor public DeveloperPortalPage (WebDriver driver){ this.driver=driver; //Initialise Elements PageFactory.initElements(driver, this); } //We will use this boolean for assertion. To check if page is opened public boolean isPageOpened(){ return heading.getText().toString().contains('Developer portal'); } public void clikOnJoin(){ joinApeeScapeButton.click(); } }

DeveloperApplyPage Page Object

E, finalmente, para nosso objeto de terceira e última página para este projeto, definimos um que representa a página que contém o formulário de aplicativo do desenvolvedor. Uma vez que temos que lidar com vários campos de formulário aqui, definimos um WebElement variável para cada campo do formulário. Encontramos cada campo por seu “id” e definimos métodos especiais de definição para cada campo que simulam pressionamentos de tecla para os campos correspondentes.

package com.toptal.webpages; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.support.FindBy; import org.openqa.selenium.support.PageFactory; public class DeveloperApplyPage { private WebDriver driver; @FindBy(tagName = 'h1') WebElement heading; @FindBy(id='developer_email') WebElement developer_email; @FindBy(id = 'developer_password') WebElement developer_password; @FindBy(id = 'developer_password_confirmation') WebElement developer_password_confirmation; @FindBy(id = 'developer_full_name') WebElement developer_full_name; @FindBy(id = 'developer_skype') WebElement developer_skype; @FindBy(id ='save_new_developer') WebElement join_toptal_button; //Constructor public DeveloperApplyPage(WebDriver driver){ this.driver=driver; //Initialise Elements PageFactory.initElements(driver, this); } public void setDeveloper_email(String email){ developer_email.clear(); developer_email.sendKeys(email); } public void setDeveloper_password(String password){ developer_password.clear(); developer_password.sendKeys(password); } public void setDeveloper_password_confirmation(String password_confirmation){ developer_password_confirmation.clear(); developer_password_confirmation.sendKeys(password_confirmation); } public void setDeveloper_full_name (String fullname){ developer_full_name.clear(); developer_full_name.sendKeys(fullname); } public void setDeveloper_skype (String skype){ developer_skype.clear(); developer_skype.sendKeys(skype); } public void clickOnJoin(){ join_toptal_button.click(); } public boolean isPageOpened(){ //Assertion return heading.getText().toString().contains('Apply to join our network as a developer'); } }

Escrevendo um Teste Simples de Selênio

Com as classes de objeto de página representando nossas páginas e as interações do usuário como seus métodos, agora podemos escrever nossa rotina de teste simples como uma série de chamadas e asserções de método simples.

programação de computador c ++
package com.toptal.tests; import com.toptal.webpages.DeveloperApplyPage; import com.toptal.webpages.DeveloperPortalPage; import com.toptal.webpages.HomePage; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; import java.net.URL; import java.util.concurrent.TimeUnit; public class ApplyAsDeveloperTest { WebDriver driver; @Before public void setup(){ //use FF Driver driver = new FirefoxDriver(); driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS); } @Test public void applyAsDeveloper() { //Create object of HomePage Class HomePage home = new HomePage(driver); home.clickOnDeveloperApplyButton(); //Create object of DeveloperPortalPage DeveloperPortalPage devportal= new DeveloperPortalPage(driver); //Check if page is opened Assert.assertTrue(devportal.isPageOpened()); //Click on Join ApeeScape devportal.clikOnJoin(); //Create object of DeveloperApplyPage DeveloperApplyPage applyPage =new DeveloperApplyPage(driver); //Check if page is opened Assert.assertTrue(applyPage.isPageOpened()); //Fill up data applyPage.setDeveloper_email(' [email protected] '); applyPage.setDeveloper_full_name('Dejan Zivanovic Automated Test'); applyPage.setDeveloper_password('password123'); applyPage.setDeveloper_password_confirmation('password123'); applyPage.setDeveloper_skype('automated_test_skype'); //Click on join //applyPage.clickOnJoin(); } @After public void close(){ driver.close(); } }

Executando o Teste

Neste ponto, a estrutura do projeto deve ser semelhante a esta:

exemplo de teste de selênio

Se você deseja executar o teste, selecione “ApplyAsDeveloperTest” na árvore, clique com o botão direito sobre ele e selecione Execute ‘ApplyAsDeveloperTest’ .

exemplo de teste de selênio

Depois que o teste foi executado, você pode ver os resultados no canto inferior esquerdo do seu IDE:

exemplo de teste de selênio

Conclusão

Objeto de página e Fábrica de página facilitam a modelagem de páginas da web no Selenium e os testam automaticamente e tornam a vida dos desenvolvedores e QAs muito mais simples. Quando bem feito, essas classes de objeto de página podem ser reutilizadas em todo o seu conjunto de testes e dar a você a oportunidade de implementar testes Selenium automatizados para seus projetos desde o início, sem comprometer o desenvolvimento ágil. Ao abstrair as interações do usuário em seus modelos de objeto de página e manter suas rotinas de teste leves e simples, você pode adaptar seu conjunto de testes às mudanças de requisitos com pouco esforço.

Espero ter conseguido mostrar a você como escrever um código de teste limpo e agradável que seja fácil de manter. Vou terminar o artigo com minha citação favorita de controle de qualidade:

Pense duas vezes, codifique uma vez!

Relacionado: Web Scraping com um navegador sem cabeça: um tutorial de fantoche

Compreender o básico

O que é o modelo de objeto de página no Selenium?

O modelo de objeto de página é um padrão de design de objeto no Selenium. As páginas da Web são representadas como classes e os elementos na página são definidos como variáveis ​​na classe, de modo que as interações do usuário podem ser implementadas como métodos na classe.

Por que usamos selênio?

O Selenium foi projetado para automatizar navegadores da web, permitindo assim que os engenheiros de software acelerem e automatizem os testes. Embora a automação de teste seja seu uso principal, o Selenium também pode ser usado para automatizar certas ações repetitivas, como tarefas básicas de administração.

O que é o teste de selênio?

O teste Selenium é o processo de usar um conjunto de ferramentas de software Selenium para facilitar a automação do teste. Na maioria dos casos, os engenheiros de software escolhem uma ou duas ferramentas Selenium para essa tarefa, mas ferramentas adicionais podem ser empregadas para atender a diferentes necessidades.

Qual é a diferença entre o modelo de objeto de página e o Page Factory?

O modelo de objeto de página é um padrão de design, conforme descrito anteriormente nesta seção. O Page Factory expande a funcionalidade do modelo de objeto de página, introduzindo recursos mais avançados. Ele permite que os usuários inicializem elementos específicos dentro do modelo de objeto de página, usando anotações.

Guia do engenheiro de dados para armazenamentos de dados não tradicionais

Ciência De Dados E Bancos De Dados

Guia do engenheiro de dados para armazenamentos de dados não tradicionais
Cuidado com o vento: opiniões sobre o boom de crescimento das energias renováveis

Cuidado com o vento: opiniões sobre o boom de crescimento das energias renováveis

Processos Financeiros

Publicações Populares
Linha de assunto - Como abordar o design de e-mail
Linha de assunto - Como abordar o design de e-mail
Gerentes de produto x Gerentes de projeto: entendendo as semelhanças e diferenças essenciais
Gerentes de produto x Gerentes de projeto: entendendo as semelhanças e diferenças essenciais
Tutorial de física de videogame - Parte II: Detecção de colisão para objetos sólidos
Tutorial de física de videogame - Parte II: Detecção de colisão para objetos sólidos
Estética e percepção - como abordar as imagens da experiência do usuário
Estética e percepção - como abordar as imagens da experiência do usuário
Escreva testes que importem: enfrente o código mais complexo primeiro
Escreva testes que importem: enfrente o código mais complexo primeiro
 
Como Facilitar a Mudança por meio da Liderança de Servo Ágil
Como Facilitar a Mudança por meio da Liderança de Servo Ágil
O lendário alpinista Jim Bridwell morre aos 73 anos
O lendário alpinista Jim Bridwell morre aos 73 anos
Tutorial Grape Gem: como construir uma API semelhante a REST em Ruby
Tutorial Grape Gem: como construir uma API semelhante a REST em Ruby
Energia híbrida: vantagens e benefícios da vibração
Energia híbrida: vantagens e benefícios da vibração
Dê a eles incentivos - como aproveitar uma estrutura de design de programa de fidelidade
Dê a eles incentivos - como aproveitar uma estrutura de design de programa de fidelidade
Publicações Populares
  • javascript obter data e hora
  • python é escrito em c
  • cartões de crédito hackeados grátis com dinheiro
  • problemas e soluções de segurança da web
  • construir um pi de framboesa do zero
  • liste os princípios do design.
  • como você usa bootstrap
Categorias
  • Receita E Crescimento
  • Aprendendo
  • Processo Interno
  • Processo De Design
  • © 2022 | Todos Os Direitos Reservados

    portaldacalheta.pt