Mini Manual : Selênio e Cumcuber usando Maven

Pré-Requisitos para configurar o cumcuber, para isso você precisaria de algumas instalações
básicas em seu sistema:

-> Configure o JDK no seu sistema (JDK 1.8 ou a versão mais recente)

-> Instale o Eclipse (Eclipse, versão mais recente)

Instalar o plugin Cucumber:

-> No Eclipse, vá para Ajuda → Instalar novo software

-> No pop-up Disponível Software, insira a URL “http://cucumber.github.com/cucumber-

eclipse/update-site”no campo Work with.

Você verá “Cucumber Eclipse Plugin” exibido no filtro; marque a caixa de seleção e clique em
Avançar, e você navegará até o pop-up Detalhes da Instalação. Clique em Avançar para
prosseguir. Aceite a licença no pop-up Revisar Licença e clique em Concluir.
Por Que Maven?

O Maven é uma ferramenta de construção de automação e é amplamente usado para projetos

Java. É usado principalmente no gerenciamento de dependências por meio do pom.xml.
Suponha que você queira atualizar os arquivos JAR e, em seu projeto, você está usando a
versão 1.25 para a dependência de Cucumber-Java. Você precisa atualizar para a versão mais
recente. Com o uso do Maven, é fácil atualizar a versão.

Configure Seu Projeto Maven

Etapa 1: Para criar um projeto Maven no Eclipse, clique em Novo → Projeto → No assistente,
selecione Projeto Maven .
Passo 2: No novo pop-up Maven Project, marque a caixa de seleção para criar seu projeto no
local padrão ou você também pode procurar e definir um novo local de sua escolha. Clique em
Next para prosseguir.

Passo 4: Na próxima tela, você terá que mencionar um ID de Grupo e um ID de Artefato de sua
própria escolha; este é o nome do seu projeto Maven. Depois de clicar no botão Concluir, um
projeto Maven será criado no Eclipse.
A estrutura do projeto criado no Eclipse será semelhante à seguinte imagem. Como você pode
ver, existe um arquivo pom.xml criado em seu projeto Maven. Este arquivo consiste no ID do
Grupo e no ID de Artefato que você inseriu e, por padrão, consiste na dependência do JUnit.
Consulte a imagem abaixo.

Passo 5: Agora, para construir uma estrutura Selenium-Cucumber para trabalharmos,

precisamos adicionar dependência para o Selenium e o Cucumber em pom.xml, o que é um
pouco semelhante à adição de arquivos JAR. Nós estaremos precisando de dependências do
seguinte:

Selenium-java

Cobertura

Cucumber-jvm-deps

Cucumber-reporting

Gherkin

JUnit

Mockito-all-1.10.19

Cucumber-core

Cucumber-java

Cucumber-junit

Nota: Certifique-se de que as versões em Cucumber-java, Cucumber -junit e Cucumber-core

sejam as mesmas, ou seja, se você estiver usando Cucumber-java-1.2.5, verifique se as versões
das outras duas dependências são as mesmas.
Passo 6: Para adicionar dependências para o acima, você deve consultar https : //
mvnrepository . com / . Depois de adicionar dependências para Pepino e Selênio, o arquivo
pom.xml ficará assim:

<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>Cucumber_Selenium</groupId>
<artifactId>Cucumber_Selenium</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>Cucumber_Selenium</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>3.7.1</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>3.7.0</version>
</dependency>
<dependency>
<groupId>info.cukes</groupId>
<artifactId>cucumber-java</artifactId>
<version>1.2.5</version>
</dependency>
<dependency>
<groupId>info.cukes</groupId>
<artifactId>cucumber-jvm-deps</artifactId>
<version>1.0.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>info.cukes</groupId>
<artifactId>cucumber-junit</artifactId>
<version>1.2.5</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.vimalselvam</groupId>
<artifactId>cucumber-extentsreport</artifactId>
<version>3.0.2</version>
</dependency>
<dependency>
<groupId>com.aventstack</groupId>
<artifactId>extentreports</artifactId>
<version>3.1.2</version>
</dependency>
</dependencies>
</project>

Etapa 7: certifique-se de atualizar o projeto depois de adicionar dependências ao pom.xml;

você pode fazer isso clicando com o botão direito em Project → Maven → Update Project .
Depois de atualizar o projeto, você verá que muitos arquivos JAR são adicionados à pasta
Maven Dependencies em seu projeto.
Etapa 8: Para continuar com a implementação do Pepino, precisamos criar três pacotes para
armazenar os arquivos de recursos, o código de definição da etapa e o código do testrunner.
Vamos criar três pacotes: recursos, seleniumgluecode e runner. Para criar um novo pacote em
src / test / java, clique com o botão direito na pasta → Novo → Pacote.

Etapa 9: Agora crie o arquivo de recurso no pacote Recursos. Clique com o botão direito →
Novo → Arquivo → Digite o nome test.feature.

Nota: Se você não encontrar "Arquivo", clique em "Outros" e selecione a opção "Arquivo".

Passo 10: Crie uma classe test.java para escrever o gluecode para os recursos escritos. Clique
com o botão direito em seleniumgluecode → Novo → Classe → digite o nome como teste e
salve.

Etapa 11: Para executar os arquivos de recursos e seus respectivos códigos, precisamos
escrever uma classe de execução JUnit. Clique com o botão direito do mouse em runner →
New → Class → digite o nome como testrunner.

A estrutura básica para escrever e executar o código está pronta e você está quase pronto para
escrever e executar scripts do Cucumber.

Cenários Básicos

Vamos considerar um cenário de login em que o usuário precisa inserir um nome de usuário e
senha, e confirmar se ele pode efetuar login. Precisamos escrever um cenário básico no
arquivo de recursos test.feature que criamos.

O cenário básico para testar a funcionalidade de login está pronto. Agora, precisamos escrever
a classe do executor de teste JUnit para executar o arquivo de recurso. Adicione o código dado
abaixo à classe testrunner.java.

package Runner;

import org.junit.runner.RunWith;

import cucumber.api.CucumberOptions;

import cucumber.api.junit.Cucumber;

@RunWith(Cucumber.class)

@CucumberOptions(

features = "src/test/javaFeatures"

,glue= {"seleniumgluecode"}

public class testrunner {

}
Execução

Para executar o código acima, clique com o botão direito do mouse no arquivo test.feature →
Run As → Cucumber feature . Ao executar o arquivo test.feature, você notará que no console
menciona a implementação de etapas ausentes. Isso ocorre porque não definimos o código para
executar as etapas.

Para começar a escrever o código de cola para as etapas, copie os fragmentos do console e cole-
os na classe test.java que criamos no pacote seleniumgluecode.

Depois de copiar o snippet, remova o "throw new PendingException ()" e escreva o código
apropriado para as etapas.

package seleniumgluecode;

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.By;

import org.openqa.selenium.WebDriver;

import org.openqa.selenium.firefox.FirefoxDriver;

import cucumber.api.java.en.Given;

import cucumber.api.java.en.Then;

import cucumber.api.java.en.When;

import org.junit.Assert;

public class test {

public static WebDriver driver;

@Given("^user is on homepage$")

public void user_is_on_homepage() throws Throwable {

System.setProperty("webdriver.gecko.driver","/Users/Documents/geckodriver");

driver = new FirefoxDriver();

driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);

driver.get("http://automationpractice.com/index.php");

@When("^user navigates to Login Page$")

public void user_navigates_to_Login_Page() throws Throwable {

driver.findElement(By.linkText("Sign in")).click();

@When("^user enters username and Password$")

public void user_enters_username_and_Password() throws Throwable {

driver.findElement(By.id("email")).sendKeys("blog.cucumber@gmail.com");
 driver.findElement(By.id("passwd")).sendKeys("Cucumber@blog");

driver.findElement(By.id("SubmitLogin")).click();

@Then("^success message is displayed$")

public void success_message_is_displayed() throws Throwable {

String exp_message = "Welcome to your account. Here you can manage all of

your personal information and orders.";

Stringactual = driver.findElement(By.cssSelector(".info-account")).getText();

Assert.assertEquals(exp_message, actual);

driver.quit();

Estamos quase prontos para executar o arquivo de recurso, mas para executar o código no
Firefox ou no Chrome, precisamos adicionar um pequeno código no código existente. Siga as
etapas na seção abaixo para entender a execução do código em diferentes navegadores.
Execução Com Diferentes Navegadores
No Selenium 3, para executar o código nos navegadores Firefox ou Chrome, precisamos usar um
driver externo.
Para executar o código no Firefox, precisamos do GeckoDriver.

Para usar isso, baixe o Geckdriver.exe para o seu sistema, e no test.java, antes de iniciar o
navegador Firefox, defina a propriedade do sistema como webdriver.gecko.driver.

System.setProperty("webdriver.gecko.driver","Mentionthepath\geckodriver.exe");

Para usar o Chrome, precisamos usar o ChromeDriver. Assim como no Firefox, também
precisamos definir a propriedade do sistema como webdriver.chrome.driver.

System.setProperty("webdriver.chrome.driver","MentionPathtothisdriver/chromedriver");

Estamos prontos para executar nosso primeiro cenário para a funcionalidade de login no Firefox /
Chrome. Adicione a propriedade do sistema para o navegador desejado à função e, em seguida,
execute o arquivo test.feature, e seu navegador será aberto e o teste da funcionalidade de login
será executado.

Após conclusão deste exercício, vou enviar como Crie Relatórios HTML Cumcuber,
até já Jonathan.