Tutorial TestNG: O que são anotações e estrutura no Selenium

O que é TestNG?

TesteNG é uma estrutura de testes de automação em que NG significa “Próxima Geração”. TestNG é inspirado em JUnit que usa as anotações (@). TestNG supera as desvantagens do JUnit e foi projetado para tornar teste de ponta a ponta fácil.

Usando TestNG, você pode gerar um relatório adequado e saber facilmente quantos casos de teste foram aprovados, reprovados e ignorados. Você pode executar os casos de teste com falha separadamente.

Por exemplo:

  • Suponha que você tenha cinco casos de teste, um método é escrito para cada caso de teste (suponha que o programa seja escrito usando o método principal sem usar testNG). Quando você executa este programa primeiro, três métodos são executados com sucesso e o quarto método falha. Em seguida, corrija os erros presentes no quarto método, agora você deseja executar apenas o quarto método porque os três primeiros métodos são executados com êxito de qualquer maneira. Isso não é possível sem usar TestNG.
  • O TestNG no Selenium fornece uma opção, ou seja, arquivo testng-failed.xml na pasta test-output. Se você deseja executar apenas casos de teste com falha, execute este arquivo XML. Ele executará apenas casos de teste com falha.

Além do conceito acima, você aprenderá mais sobre TestNG, como quais são as vantagens do TestNG, como criar métodos de teste usando anotações @test, como converter essas classes em arquivo de conjunto de testes e executar através do eclipse bem como na linha de comando.

Por que usar TestNG com Selenium?

Os testes padrão do Selenium não geram um formato adequado para os resultados do teste. Usando TestNG no Selenium, podemos gerar resultados de testes.

A maioria dos usuários do Selenium usa isso mais do que Junito por causa de suas vantagens. Existem tantos recursos no TestNG, mas vamos nos concentrar apenas nos mais importantes que podemos usar no Selenium. Sigawing são os principais recursos do Selenium TestNG:

  • Gere o relatório em um formato adequado, incluindo o número de execuções de casos de teste, o número de casos de teste aprovados, o número de casos de teste com falha e o número de casos de teste ignorados.
  • Vários casos de teste podem ser agrupados mais facilmente convertendo-os no arquivo testng.xml. No qual você pode priorizar qual caso de teste deve ser executado primeiro.
  • O mesmo caso de teste pode ser executado várias vezes sem loops apenas usando a palavra-chave chamada 'contagem de invocações'.
  • Usando testng, você pode executar vários casos de teste em vários navegadores, ou seja, cruzar teste de navegador.
  • A estrutura TestNG pode ser facilmente integrada com ferramentas como TestNG Maven, Jenkins, etc.
  • As anotações usadas nos testes são muito fáceis de entender, por exemplo: @BeforeMethod, @AfterMethod, @BeforeTest, @AfterTest
  • O WebDriver não possui mecanismo nativo para geração de relatórios. TestNG pode gerar o relatório em um formato legível como o mostrado abaixo.
  • Use TestNG com Selenium

  • TestNG simplifica a forma como os testes são codificados. Não há mais necessidade de um método principal estático em nossos testes. A sequência de ações é regulada por anotações fáceis de entender que não exigem que os métodos sejam estáticos.
  • Use TestNG com Selenium

    Use TestNG com Selenium

  • Exceções não detectadas são tratadas automaticamente pelo TestNG sem encerrar o teste prematuramente. Essas exceções são relatadas como etapas com falha no relatório.

Vantagens do TestNG sobre o JUnit

Existem três vantagens principais do TestNG sobre o JUnit:

  • As anotações são mais fáceis de entender
  • Os casos de teste podem ser agrupados mais facilmente
  • Testes paralelos são possíveis

O que é anotação no TestNG?

Anotações em TestNG são linhas de código que podem controlar como o método abaixo delas será executado. Eles são sempre precedidos pelo símbolo @. Um exemplo de TestNG muito antigo e rápido é o mostrado abaixo.

Anotação em TestNG

As anotações serão discutidas later na seção chamada “Anotações usadas no TestNG”, então está perfeitamente ok se você ainda não entendeu o exemplo do TestNG acima. É importante observar por enquanto que as anotações no TestNG são mais fáceis de codificar e entender do que no JUnit.

A capacidade de executar testes em paralelo está disponível no TestNG, mas não no JUnit, portanto, a estrutura TestNG é mais preferida para testadores que usam Selenium Grid.

Como escrever casos de teste no TestNG?

Passo 1) Escreva sua lógica de negócios e insira as anotações TestNG em seu código.
Passo 2) Adicione mais informações como nome da classe, nome dos grupos, nome do pacote, etc.
Passo 3) Execute o TestNG.

Criar caso de teste usando anotações TestNG

Agora, aprenderemos como criar nosso primeiro caso de teste usando anotações TestNG no Selenium:

Antes de criarmos um caso de teste, devemos primeiro configurar um novo projeto TestNG em Eclipse e nomeie-o como “FirstTestNGProject”.

Configurando um novo projeto TestNG

- Clique em Arquivo > Novo > Java Projeto

Configurando um novo projeto TestNG

- Digite “FirstTestNGProject” como o nome do projeto e clique em Avançar.

Configurando um novo projeto TestNG

- Agora começaremos a importar as bibliotecas TestNG para o nosso projeto. Clique na guia “Bibliotecas” e depois em “Adicionar Biblioteca…”

Configurando um novo projeto TestNG

- Na caixa de diálogo Adicionar biblioteca, escolha “TestNG” e clique em Avançar.

Configurando um novo projeto TestNG

- Clique em Concluir.

Configurando um novo projeto TestNG

Você deve notar que TestNG está incluído na lista de Bibliotecas.

Configurando um novo projeto TestNG

- Agora adicionaremos os arquivos JAR que contêm a API Selenium. Esses arquivos são encontrados no driver cliente Java do qual baixamos https://www.selenium.dev/downloads/ quando estávamos instalando o Selenium e Eclipse nos capítulos anteriores.

Configurando um novo projeto TestNG

Em seguida, navegue até onde você colocou os arquivos JAR do Selenium.

Configurando um novo projeto TestNG

Depois de adicionar os JARs externos, sua tela deverá ficar assim.

Configurando um novo projeto TestNG

- Clique em Concluir e verifique se nosso FirstTestNGProject está visível em EclipseJanela do Explorador de Pacotes.

Configurando um novo projeto TestNG

Como criar um novo arquivo de teste TestNG

Agora que terminamos de configurar nosso projeto neste tutorial TestNG, vamos criar um novo arquivo TestNG.

- Clique em 'src' e escolha outro.
Clique com o botão direito na pasta do pacote “src” e escolha Novo> Outro…

Crie um novo arquivo de teste TestNG

- Selecione a classe TestNG.
Clique na pasta TestNG e selecione a opção “Classe TestNG”. Clique em Avançar.

Crie um novo arquivo de teste TestNG

- Digite os valores.
Digite os valores indicados abaixo na entrada apropriada boxes e clique em Concluir. Observe que nomeamos nosso arquivo Java como “FirstTestNGFile”.

Crie um novo arquivo de teste TestNG

- Modelo criado.
Eclipse deve criar automaticamente o modelo para nosso arquivo TestNG mostrado abaixo.

Crie um novo arquivo de teste TestNG

Codificação do nosso primeiro exemplo de caso de teste TestNG

Vamos agora criar nosso primeiro Caso de teste isso verificará se a página inicial da Mercury Tours está correta. Digite seu código conforme mostrado no exemplo TestNG abaixo:

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;

public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver ; 
     
  @Test
  public void verifyHomepageTitle() {
       
      System.out.println("launching firefox browser"); 
      System.setProperty("webdriver.gecko.driver", driverPath);
      driver = new FirefoxDriver();
      driver.get(baseUrl);
      String expectedTitle = "Welcome: Mercury Tours";
      String actualTitle = driver.getTitle();
      Assert.assertEquals(actualTitle, expectedTitle);
      driver.close();
  }
}

Observe o seguintewing.

  • TestNG não exige que você tenha um método main().
  • Os métodos não precisam ser estáticos.
  • Usamos a anotação @Test. @Test é usado para informar que o método abaixo dele é um caso de teste. Neste caso, definimos o método verifyHomepageTitle() como nosso caso de teste, então colocamos uma anotação '@Test' acima dele.
  • Como usamos anotações no TestNG, precisávamos importar o pacote org.testng.annotations.*.
  • Usamos a classe Assert. A classe Assert é usada para conduzir operações de verificação no TestNG. Para usá-lo, precisamos importar o pacote org.testng.Assert.

Você pode ter vários casos de teste (portanto, várias anotações @Test) em um único arquivo TestNG. Isso será abordado com mais detalhes later na seção “Anotações usadas no TestNG”.

Executando o teste

Para executar o teste, basta executar o arquivo em Eclipse como você normalmente faz. Eclipse fornecerá duas saídas – uma na janela Console e outra na janela TestNG Results.

Executando o teste

Executando o teste

Verificando relatórios criados por TestNG

A janela Console em Eclipse fornece um relatório baseado em texto dos resultados do nosso caso de teste, enquanto a janela Resultados do TestNG nos fornece um relatório gráfico.

Verificando relatórios criados por TestNG

Gerando relatórios HTML

TestNG tem a capacidade de gerar relatórios em formato HTML.

- Após executar nosso FirstTestNGFile que criamos na seção anterior, clique com o botão direito no nome do projeto (FirstTestNGProject) na janela Project Explorer e clique na opção “Atualizar”.

Gerando relatórios HTML

- Observe que uma pasta “test-output” foi criada. Expanda-o e procure um arquivo index.html. Este arquivo HTML é um relatório dos resultados do teste mais recente.

Gerando relatórios HTML

- Double-clique no arquivo index.html para abri-lo Eclipsenavegador da web integrado. Você pode atualizar esta página a qualquer momento após executar novamente o teste, simplesmente pressionando F5, como em navegadores comuns.

Gerando relatórios HTML

Anotações usadas no TestNG

Na seção anterior, você conheceu a anotação @Test. Agora, estudaremos anotações mais avançadas e seus usos.

Vários casos de teste

Podemos usar várias anotações @Test em um único arquivo TestNG. Por padrão, os métodos anotados por @Test são executados em ordem alfabética. Veja o código abaixo. Embora os métodos c_test, a_test e b_test não estejam organizados em ordem alfabética no código, eles serão executados como tal.

Anotações usadas no TestNG

Execute este código e na página index.html gerada, clique em “Visualização cronológica”.

Anotações usadas no TestNG

parâmetros

Caso queira que os métodos sejam executados em uma ordem diferente, utilize o parâmetro “prioridade”. Parâmetros são palavras-chave que modificam a função da anotação.

  • Os parâmetros exigem que você atribua um valor a eles. Você faz isso colocando um “=” próximo a eles e seguido pelo valor.
  • Os parâmetros são colocados entre parênteses que são colocados logo após a anotação, como o trecho de código mostrado abaixo.

parâmetros

TestNG executará a anotação @Test com o valor de prioridade mais baixo até o maior. Não há necessidade de que seus valores de prioridade sejam consecutivos.

parâmetros

O relatório HTML TestNG confirmará que os métodos foram executados com base no valor crescente de prioridade.

parâmetros

Parâmetros múltiplos

Além de “prioridade”, @Test tem outro parâmetro chamado “alwaysRun” que só pode ser definido como “true” ou “false”. Para usar dois ou mais parâmetros em uma única anotação, separe-os com uma vírgula como o mostrado abaixo.

@Test(priority = 0, alwaysRun = true)

Parâmetros múltiplos

@BeforeTest e @AfterTest

@AntesTeste métodos sob esta anotação serão executados antes do primeiro caso de teste no arquivo TestNG.
@DepoisTeste métodos sob esta anotação serão executados depois que todos os casos de teste no arquivo TestNG forem executados.

Considere o código abaixo.

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;
public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver ; 
     
     @BeforeTest
      public void launchBrowser() {
          System.out.println("launching firefox browser"); 
          System.setProperty("webdriver.gecko.driver", driverPath);
          driver = new FirefoxDriver();
          driver.get(baseUrl);
      }
      @Test
      public void verifyHomepageTitle() {
          String expectedTitle = "Welcome: Mercury Tours";
          String actualTitle = driver.getTitle();
          Assert.assertEquals(actualTitle, expectedTitle);
     }
      @AfterTest
      public void terminateBrowser(){
          driver.close();
      }
}

Aplicando a lógica apresentada pela tabela e pelo código acima, podemos prever que a sequência pela qual os métodos serão executados é:

  • 1st – lançamentoNavegador()
  • 2nd – verificarHomepageTitle()
  • 3rd –terminarBrowser()

A colocação dos blocos de anotação pode ser trocada sem afetar a ordem cronológica pela qual serão executados. Vamos entender com um exemplo TestNG e tentar reorganizar os blocos de anotação de forma que seu código fique semelhante ao abaixo.

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;
public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver ; 
     @AfterTest                            //Jumbled
      public void terminateBrowser(){
          driver.close();
      }
     @BeforeTest                            //Jumbled
      public void launchBrowser() {
          System.out.println("launching firefox browser"); 
          System.setProperty("webdriver.gecko.driver", driverPath);
          driver = new FirefoxDriver();
          driver.get(baseUrl);
      }
      @Test                                //Jumbled
      public void verifyHomepageTitle() {
          String expectedTitle = "Welcome: Mercury Tours";
          String actualTitle = driver.getTitle();
          Assert.assertEquals(actualTitle, expectedTitle);
     }
      
}

Execute o código acima e observe que

Parâmetros múltiplos

@BeforeMethod e @AfterMethod

@BeforeMethod métodos sob esta anotação serão executados antes de cada método em cada caso de teste.
@AfterMethod métodos sob esta anotação serão executados após cada método em cada caso de teste.

Na Mercury Tours, suponha que gostamos de verificar os títulos das páginas de destino dos dois links abaixo.

Parâmetros múltiplos

O fluxo do nosso teste seria:

  • Vá para a página inicial e verifique seu título.
  • Clique em CADASTRE-SE e verifique o título da página de destino.
  • Volte para a página inicial e verifique se ainda tem o título correto.
  • Clique em APOIO e verifique o título da página de destino.
  • Volte para a página inicial e verifique se ainda tem o título correto.

O código abaixo ilustra como @BeforeMethod e @AfterMethod são usados ​​para executar com eficiência o cenário mencionado acima.

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;
@Test
public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver; 
    public String expected = null;
    public String actual = null;
        @BeforeTest
      public void launchBrowser() {
          System.out.println("launching firefox browser"); 
          System.setProperty("webdriver.gecko.driver", driverPath);
          driver= new FirefoxDriver();
          driver.get(baseUrl);
      }
      
      @BeforeMethod
      public void verifyHomepageTitle() {
          String expectedTitle = "Welcome: Mercury Tours";
          String actualTitle = driver.getTitle();
          Assert.assertEquals(actualTitle, expectedTitle);
      }
          @Test(priority = 0)
      public void register(){
          driver.findElement(By.linkText("REGISTER")).click() ;
          expected = "Register: Mercury Tours";
          actual = driver.getTitle();
          Assert.assertEquals(actual, expected);
      }
          @Test(priority = 1)
      public void support() {
            driver.findElement(By.linkText("SUPPORT")).click() ;
            expected = "Under Construction: Mercury Tours";
            actual = driver.getTitle();
            Assert.assertEquals(actual, expected);
      }
      @AfterMethod
      public void goBackToHomepage ( ) {
            driver.findElement(By.linkText("Home")).click() ;
      }
       
      @AfterTest
      public void terminateBrowser(){
          driver.close();
      }
}

Depois de executar este teste, seu TestNG deve relatar o seguintewing seqüência.

Parâmetros múltiplos

Simplificando, @BeforeMethod deve conter métodos que você precisa para executar antes cada caso de teste enquanto @AfterMethod deve conter métodos que você precisa para executar depois de cada caso de teste.

Resumo das anotações do TestNG

@AntesSuite: o método anotado será executado antes que todos os testes deste conjunto sejam executados.

@AfterSuite: o método anotado será executado após a execução de todos os testes deste conjunto.

@AntesTeste: o método anotado será executado antes de qualquer método de teste pertencente às classes dentro da tag ser executado.

@DepoisTeste: O método anotado será executado após a execução de todos os métodos de teste pertencentes às classes dentro da tag.

@BeforeGroups: a lista de grupos que este método de configuração executará antes. É garantido que esse método seja executado pouco antes do primeiro método de teste que pertence a qualquer um desses grupos ser invocado.

@AfterGroups: a lista de grupos nos quais esse método de configuração será executado. É garantido que este método seja executado logo após o último método de teste que pertence a qualquer um desses grupos ser invocado.

@Antes da aula: o método anotado será executado antes que o primeiro método de teste na classe atual seja invocado.

@Depois da aula: O método anotado será executado após todos os métodos de teste na classe atual terem sido executados.

@BeforeMethod: O método anotado será executado antes de cada método de teste.

@AfterMethod: O método anotado será executado após cada método de teste.

@Teste: O método anotado faz parte de um caso de teste

Conclusão

  • TestNG é um ensaio framework que é capaz de facilitar o entendimento dos testes do Selenium e gerar relatórios de fácil entendimento.
  • As principais vantagens do TestNG sobre o JUnit são as seguinteswing.
    • As anotações são mais fáceis de usar e entender.
    • Os casos de teste podem ser agrupados mais facilmente.
    • TestNG nos permite criar testes paralelos.
  • A janela Console em Eclipse gera um resultado baseado em texto, enquanto a janela TestNG é mais útil porque nos fornece uma saída gráfica do resultado do teste, além de outros detalhes significativos.tails tais como:
    • Tempos de execução de cada método.
    • A ordem cronológica pela qual os métodos foram executados
  • TestNG é capaz de gerar relatórios baseados em HTML.
  • As anotações podem usar parâmetros exatamente como os métodos Java TestNG usuais.
  • TestNG Dataprovider é uma forma de passar parâmetros para a função de teste que passa valores diferentes em casos de teste em uma única execução.