Guia do engenheiro de dados para armazenamentos de dados não tradicionais
Ciência De Dados E Bancos De Dados
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.
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 é 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 ++
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”
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
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.
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”.
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.
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(); } }
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.
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;
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(); } }
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'); } }
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(); } }
Neste ponto, a estrutura do projeto deve ser semelhante a esta:
Se você deseja executar o teste, selecione “ApplyAsDeveloperTest” na árvore, clique com o botão direito sobre ele e selecione Execute ‘ApplyAsDeveloperTest’ .
Depois que o teste foi executado, você pode ver os resultados no canto inferior esquerdo do seu IDE:
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:
Relacionado: Web Scraping com um navegador sem cabeça: um tutorial de fantochePense duas vezes, codifique uma vez!
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.
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 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.
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.