Suponha que você precise escrever testes Selenium. Seu plano é escrevê-los em Java. Primeiro, você precisará escolher o framework de testes que usará para o código dos seus testes. Em seguida, precisará de uma ferramenta de automação de build para o seu projeto. Talvez você já saiba qual framework e qual builder usará, mas não saiba como configurá-los para o seu projeto.

Neste artigo, vamos analisar o TestNG e o JUnit. Ambos são frameworks de teste Java populares. Também veremos alguns builders populares, como Apache Maven, Gradle e Apache Ant. Selecionamos o TestNG e o JUnit por serem os frameworks de teste Java mais populares. Embora o TestNG tenha algumas vantagens sobre o JUnit, este último é mais utilizado em projetos de desenvolvimento de software. Demonstraremos como criar e executar testes Selenium usando esses frameworks e builders.

Antes de começar a escrever testes e usar frameworks e ferramentas de build, é necessário garantir que o JDK esteja instalado em sua estação de trabalho e verificar o navegador instalado. Você precisa instalar uma IDE e um driver de navegador, correspondente ao navegador no qual executará seus testes. Pode ser necessário configurar ou alterar algumas configurações de ambiente.

Se o Java JDK não estiver instalado na estação de trabalho onde você desenvolverá e executará os testes, será necessário instalá-lo. No momento da redação deste artigo, a versão mais recente do Java disponível é a 11.0.2. Você pode baixá-la aqui. aqui. Após a instalação, você deve definir a variável de ambiente Java_HOME. Por exemplo:

Defina Java_HOME=C:\Program Files\Java\jdk-11.0.2

Nos exemplos demonstrados neste artigo, usaremos o IntelliJ IDEA. Basta instalar a versão Community mais recente. O menu suspenso permite escolher um pacote de instalação para uma determinada versão do Java. Como você instalou o JDK 11, selecione a versão do IDEA para Java 11. https://www.jetbrains.com/idea/. Se você tiver outra versão do JDK instalada em sua estação de trabalho, selecione o pacote do IDEA apropriado. O procedimento é mostrado na imagem abaixo.

Instale o driver correspondente ao tipo e versão do navegador que você usará para os testes. Nos exemplos apresentados neste artigo, usamos o navegador Google Chrome. Os drivers para o Google Chrome podem ser baixados aqui. aqui.Descompacte o arquivo em um diretório de sua escolha.

Após a instalação e configuração do conjunto básico de ferramentas, podemos começar a escrever os testes de demonstração.

Para demonstrar o uso de uma estrutura de testes com uma ferramenta de compilação, precisamos de um exemplo de alguns testes. No teste de exemplo, abriremos o Site da ExperitestEncontre o link “Webcasts” na página inicial do Experitest, clique nele e verifique o título da página que será aberta. O teste de exemplo é representado por dois arquivos: TestBase.java e ViewTest.java. O primeiro arquivo é a classe responsável pela preparação do teste, inicialização do driver do navegador e sua configuração. O segundo arquivo é a classe que contém o próprio teste. Aqui está o código:

[java] public class TestBase { protected static WebDriver driver; @BeforeClass public static void setUp(){ System.setProperty(“webdriver.chrome.driver”, “D:\\chrome-driver-73\\chromedriver.exe”); driver = new ChromeDriver(); driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS); } @AfterClass public static void tearDown(){ driver.close(); driver.quit(); } } System.setProperty(“webdriver.chrome.driver”, “D:\\chrome-driver-73\\chromedriver.exe”); – Este método define o caminho para o driver do Chrome em sua estação de trabalho. O conteúdo da classe ViewTest.java: public class ViewTest extends TestBase { @Test public void test() { driver.get(“https://experitest.com/”); WebElement linkToWebinars = driver.findElement(By.linkText(“Webcasts”)); linkToWebinars.click(); WebElement headerForWebinar = driver.findElement(By.xpath(“//div[@class='papers2 image']/p[@class='title1′]”)); Assert.assertEquals(headerForWebinar.getText(), “From Tester to Developer: Tips and Insights”); } } [/java]

Os arquivos possuem anotações `@BeforeClass`, `@AfterClass` e `@Test`, que são incluídas tanto no TestNG quanto no JUnit. O método `Assert.assertEquals` também é usado em ambos os frameworks e está incluído no teste, embora a ordem dos parâmetros seja diferente em cada um. No método `Assert.assertEquals` do TestNG, o parâmetro `asserted` vem primeiro e representa o valor real. O valor esperado é o segundo parâmetro. Por outro lado, o método `Assert.assertEquals` do JUnit usa a ordem inversa dos parâmetros de valor real e esperado: o valor esperado vem como o primeiro parâmetro e o valor real como o segundo.

  [java]Assert.assertEquals(“From Tester to Developer: Tips and Insights”, headerForWebinar.getText());[/java]

Nas seções seguintes, demonstraremos como criar e executar testes com uma determinada estrutura e construtor escolhidos para este artigo. Assumimos de antemão que você já tenha o JDK, o IDEA e um driver de navegador instalados e configurados.

Framework TestNG e Apache Maven

O Apache Maven é uma ferramenta de gerenciamento de dependências e automação de compilação. O Maven se baseia em convenções, fornece comandos predefinidos e prescreve uma estrutura de projeto rigorosa. O arquivo de configuração do Maven é o pom.xml.

Etapa 1

Instale a ferramenta Apache Maven para compilar seu projeto Java. Para isso, baixe a versão mais recente do Maven. mavenNo momento da redação deste artigo, a versão mais recente disponível do Maven era a 3.6.0. Descompacte o arquivo em qualquer diretório. Defina as variáveis ​​de ambiente:

  [java] set M2_HOME=C:\apache-maven-3.6.0 set PATH=%M2_HOME%\bin. [/java]

Etapa 2

Crie um novo projeto Maven no IntelliJ IDEA, adicione as informações sobre o groupID, artifactID e a versão do projeto criado. Especifique o nome e a localização do projeto. Após essas etapas, a estrutura do projeto será criada e o arquivo pom.xml, que controla o processo de build, será colocado na raiz do projeto. A captura de tela abaixo exibe a estrutura do projeto e o conteúdo do arquivo pom.xml. Ele contém parâmetros definidos durante o fluxo de criação do projeto. Na verdade, as dependências precisam ser definidas no arquivo de build para que seja possível trabalhar com testes automatizados e usar um framework de testes. Além das dependências, é necessário definir outros artefatos. Todos os parâmetros, artefatos e dependências são adicionados nas seções correspondentes do arquivo pom.xml.

Etapa 3

Especifique a lista de bibliotecas para criar os testes. Adicione o plugin principal – o compilador. Ele é usado por padrão e não precisa ser especificado, mas você pode especificar a versão. O conteúdo da seção de plugins do arquivo de compilação é mostrado aqui.

  [html] org.apache.maven.plugins plugin-compilador-maven 3.8.0 [/html]

Para trabalhar com o framework TestNG, é necessário adicionar sua definição na seção de dependências do arquivo pom.xml. A seção de dependências do arquivo pom.xml para a conexão do framework TestNG ao projeto está como mostrado aqui.

[html 1=”https://mvnrepository.com/artifact/org.testng/testng” 2=”–>” 3=” ” 4=” org.testng ” 5=” testando ” 6=” 6.14.3 ” 7=” ” 8=”[/html” language=””] Os parâmetros groupId, artifactId e version podem ser encontrados no repositório central do Maven. Basta pesquisar por TestNG, selecionar a versão mais recente e a seção de dependências com esses parâmetros será exibida. Copie e cole-os no arquivo pom.xml do seu projeto. Da mesma forma, a biblioteca selenium-api é conectada ao seu projeto. A seção de dependências para conexão com o Selenium é mostrada aqui. [html] org.seleniumhq.selenium API do Selenium 3.14.0 [/html]

Para trabalhar com o WebDriver no navegador Chrome, é necessária a biblioteca selenium-chrome-driver. Adicione-o à seção de dependências do arquivo pom.xml.

[html] org.seleniumhq.selenium driver-cromo-selenium 3.14.0 [/html]

Além do Maven Central, há repositório principal do Maven Você pode obter todas as informações necessárias em. O arquivo pom.xml configurado para o nosso projeto é mostrado abaixo.

  [html] 4.0.0 Modelo Modelo 1.0-SNAPSHOT org.seleniumhq.selenium API do Selenium 3.14.0 org.testng testando 6.14.3 org.seleniumhq.selenium driver-cromo-selenium 3.14.0 org.apache.maven.plugins plugin-compilador-maven 3.6.0 [/html]

Todas as bibliotecas definidas na seção de dependências do arquivo pom.xml devem ser baixadas do repositório Maven. Para obter as bibliotecas necessárias, você precisa atualizar seu projeto.

Para isso, clique no botão "Reimportar" na janela de ferramentas "Projetos Maven" do IDEA IDE. Todas as dependências especificadas serão baixadas e, durante a criação do teste, as bibliotecas necessárias serão acessadas por meio de diretivas de importação do Java.

Etapa 4

Adicione seus testes à pasta test.java. Neste artigo, adicionamos exemplos de teste, cujo código é mostrado no primeiro parágrafo.

Etapa 5

Se você planeja executar todos os testes sequencialmente, pode pular esta etapa. Mas se você pretende gerenciar o conjunto de testes posteriormente, precisará usar o arquivo testng.xml. Adicione o subdiretório resources ao diretório test e crie um arquivo testng.xml dentro dele.

Especifique no seu arquivo testng.xml os testes que você vai executar. No nosso caso, de acordo com o exemplo de teste, há um conjunto de testes com uma classe de teste. O conteúdo do arquivo test.xml para o teste de exemplo é mostrado aqui.

  [html] [/html]

Como definimos os testes para o lançamento no arquivo test.xml, é necessário fornecer ao Maven as informações necessárias. Adicione as seguintes linhas à seção de plugins do arquivo pom.xml. O conteúdo da seção do plugin correspondente é mostrado aqui.

  [html] … org.apache.maven.plugins plugin maven-surefire 3.0.0-M3 src/test/resources/testng.xml … [/html]

Etapa 6

Agora os testes podem ser executados no console da IDE usando o Maven. Digite o comando `mvn clean test`. O parâmetro `clean` instrui o Maven a remover todas as compilações anteriores, se houver, e o parâmetro `test` instrui o Maven a executar os testes.

Se você seguiu as instruções, seu teste de exemplo será executado com sucesso. O resultado da execução é mostrado na imagem abaixo.

Framework JUnit e Apache Maven

Os passos para configurar o framework JUnit com o Apache Maven para projetos são praticamente os mesmos que para o caso em que o framework TestNG é utilizado. A única diferença está no passo 3, quando as dependências do framework de testes são adicionadas ao arquivo pom.xml. A seção de dependências do JUnit no arquivo de compilação estará aqui.

  [html] junito junito 4.12 teste [/html]

Digite o comando `mvn clean test` na janela do terminal e execute os testes do projeto. O resultado da execução será o mostrado na captura de tela abaixo.

JUnit + Gradle:

O Gradle é uma ferramenta de gerenciamento de dependências e automação de compilação que foi construída com base nos conceitos do Ant e do Maven. A principal diferença do Gradle é que ele não usa arquivos XML, ao contrário do Ant ou do Maven. O Gradle usa uma linguagem de domínio específico (DSL), baseada em Groovy. Isso resulta em arquivos de configuração menores. O arquivo de configuração do Gradle é chamado, por convenção, de build.gradle.

Partimos do pressuposto que o JDK, o IDEA e os drivers do navegador estão instalados e configurados em sua estação de trabalho.

Etapa 1

Instale o Gradle. A versão atual do Gradle é a 5.4.

Baixe a versão mais recente de https://gradle.org/releases/.

Descompacte o arquivo, por exemplo, no disco local C.

Defina as seguintes variáveis ​​de ambiente:

GRADLE_HOME=C:\gradle-5.4,

CAMINHO=%GRADLE_HOME%\bin

Etapa 2

Crie um projeto Gradle no IntelliJ IDEA, selecione o Gradle Builder, especifique a versão do SDK e as bibliotecas e frameworks adicionais. Adicione informações sobre o groupID, artifactID e a versão do projeto criado. Defina as opções do Gradle. Especifique o nome e o local do projeto. Após a conclusão dessas etapas, a estrutura do projeto será criada e o arquivo `gradle.build`, que controla o processo de build, será colocado na raiz do projeto. A captura de tela abaixo exibe a estrutura do projeto e o conteúdo do arquivo de build do projeto – `build.gradle`. Na verdade, as dependências precisam ser definidas no arquivo de build para que seja possível começar a trabalhar com testes automatizados e usar o framework de testes. Além das dependências, é necessário definir outros artefatos. Todos os parâmetros, artefatos e dependências são adicionados nas seções correspondentes do arquivo `build.gradle`.

Etapa 3

Por padrão, o Gradle inclui uma referência ao framework JUnit na seção de dependências. Você pode ver isso na captura de tela acima. Para adicionar referências às bibliotecas selenium-api e selenium-chrome-driver na seção de dependências do Gradle, precisamos procurar por essas bibliotecas no repositório central do Maven. Em seguida, nos resultados da pesquisa, devemos selecionar a referência para o construtor Gradle. A referência para selenium-API na seção de dependências ficará assim:

[java] //https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-api compile group: 'org.seleniumhq.selenium', name: 'selenium-api', version: '3.14.0' A referência à biblioteca selenium-chrome-driver será semelhante a: //https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-chrome-driver compile group: 'org.seleniumhq.selenium', name: 'selenium-chrome-driver', version: '3.14.0' [/java]

Após configurar todas as dependências, atualize o projeto clicando no botão de atualização na barra de ferramentas do Gradle, antes de declarar as classes referenciadas nas diretivas de importação.

Adicione seus testes à pasta test.java. Para executar o teste, clique no botão "Executar Tarefa Gradle" na barra de ferramentas do Gradle.

No campo "Linha de comando" da janela de diálogo que aparece em seguida, defina a tarefa a ser executada e clique no botão "OK". O teste será iniciado e o registro do teste bem-sucedido será impresso no console, conforme mostrado na imagem abaixo.

TestNG + Gradle:

Os passos para configurar o framework TestNG com o Gradle Builder para projetos são praticamente os mesmos que para o caso em que o framework JUnit é utilizado. A única diferença está no passo 3, quando as dependências do framework de testes são adicionadas ao arquivo build.gradle. Para a conexão com o TestNG, é necessário substituir a referência ao JUnit pela referência ao framework TestNG.

Adicione uma referência ao framework TestNG, como mostrado abaixo. Essa string se refere à versão mais recente do framework TestNG no repositório Maven.

  [java] // https://mvnrepository.com/artifact/org.testng/testng testCompile group: 'org.testng', name: 'testng', version: '6.14.3' [/java]

Adicione seus testes à pasta test.java. Se precisar gerenciar seus testes, crie um arquivo testng.xml e adicione-o à pasta src/test/resources/. A estrutura de exemplo do arquivo testng.xml é mostrada aqui.

  [html] [/html]

Para que o Gradle procure e execute o testng após a compilação, você precisa adicionar a tarefa de teste ao final do arquivo e Especifique onde está o arquivo testng.xml.

Para executar o teste, clique no botão "Executar Tarefa Gradle" na barra de ferramentas do Gradle. No campo "Linha de comando" da janela de diálogo que aparece em seguida, defina a tarefa a ser executada e clique no botão "OK". O teste será iniciado e o registro do teste bem-sucedido será exibido no console, conforme mostrado na imagem abaixo.

TestNG + Apache Ant

Apache Ant (“Another Neat Tool”) é uma biblioteca Java usada para automatizar processos de compilação de aplicações Java. Além disso, o Ant pode ser usado para compilar aplicações que não utilizam Java. Os arquivos de compilação do Ant são escritos em XML e, por convenção, são chamados de build.xml. A principal vantagem do Ant é a sua flexibilidade. O Ant não impõe nenhuma convenção de codificação ou estrutura de projeto específica.

Partimos do pressuposto de que o JDK, o IDEA e o driver do navegador estão instalados e configurados.

Etapa 1

Instale o Apache Ant. Ele pode ser baixado do site [inserir link aqui]. site oficialBaixe o Apache Ant 1.10.5, pois ele é compatível com Java 8 e versões superiores. Descompacte o arquivo baixado, por exemplo, no seu disco local C. Defina a seguinte variável de ambiente:

Defina ANT_HOME=C:\apache-ant-1.10.5

Defina PATH=%Java_HOME%\bin;%ANT_HOME%\bin

Etapa 2

Crie um novo projeto na IDE. Como o IDEA não oferece a opção de criar um projeto Ant, crie um projeto Java simples. Ignore a criação do projeto a partir de um modelo. Selecione o nome e o local do projeto. Após as etapas de configuração, o projeto na IDE ficará semelhante à captura de tela abaixo.

Para estruturar o projeto, adicione as subpastas test.java e test.resources.

Etapa 3

Em seguida, você precisa adicionar as bibliotecas correspondentes. Para isso, baixe as bibliotecas, coloque-as na pasta `lib` e conecte-as ao projeto. Crie uma pasta `lib` em seu projeto e baixe as bibliotecas para dentro dela. repositório Maven principal:

common-exec-1.3.jar

guava-27.0.1-jre.jar – conjunto de bibliotecas úteis.

jcommander-1.72.jar – a biblioteca para analisar a linha de comando.

okhttp-3.14.1.jar – a biblioteca que o Selenium usa para trabalhar com o driver e o servidor.

okio-1.17.3.jar – mais uma biblioteca adicional que complementa o Java.io e o Java.nio.

selenium-api-3.14.0.jar – a biblioteca para a criação de scripts Selenium WebDriver.

selenium-chrome-driver-3.14.0.jar – a biblioteca que o Selenium usa para trabalhar com o webdriver do Google Chrome.

selenium-remote-driver-3.14.0.jar – a biblioteca para a criação de scripts Selenium WebDriver.

testng-6.14.2.jar – Framework TestNG.

Após a adição de todas as bibliotecas, o conteúdo da pasta lib ficará assim:

Em seguida, essas bibliotecas devem ser conectadas ao projeto. Nas Configurações do Projeto do IDEA IDE, selecione a opção Módulos. Na aba Dependências, adicione o caminho para a pasta com as bibliotecas.

Etapa 4

Crie o arquivo de compilação build.xml na pasta raiz do projeto. Defina as tarefas: limpeza, compilação e teste. Segue abaixo um exemplo do arquivo build.xml com as tarefas definidas.

  [html] [/html]

Etapa 5

Adicione seus testes à pasta test.java.

Etapa 6

Crie um arquivo para gerenciar seus testes. Adicione o arquivo testng.xml à pasta src/test/resources/.

  [html] Adicione regras para compilar e executar testes ao arquivo build.xml: [/html]

Etapa 7

Em seguida, adicione o arquivo de compilação à ferramenta Ant Build:

Selecione a tarefa e execute-a:

Na captura de tela abaixo, você pode ver o resultado da execução da tarefa.

JUnit + Apache Ant:

Os passos para a criação e execução de um projeto de teste Java são os mesmos descritos anteriormente. A diferença reside no primeiro passo: em vez do TestNG, a biblioteca JUnit é baixada e instalada.

junit-4.12.jar – Framework JUnit.

hamcrest-all-1.3.jar – uma biblioteca adicional necessária para o funcionamento do JUnit.

O arquivo build.xml para o framework JUnit terá a seguinte aparência.

  [html] As regras para compilar e executar testes são adicionadas ao arquivo build.xml da seguinte forma: [/html]

Adicione o arquivo de compilação à ferramenta Ant Build. Selecione a tarefa JUnit e execute-a.

O registro de compilação e execução dos testes é mostrado na imagem abaixo.

Neste artigo, discutimos e descrevemos como usar os frameworks Java JUnit e TestNG com ferramentas de construção populares. Agora você sabe como iniciar seu projeto de automação e concluí-lo com sucesso.