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

O que é o TestNG?

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

utilização 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. Então corrija os erros presentes no quarto método, agora você quer executar apenas o quarto método porque os três primeiros métodos são executados com sucesso de qualquer maneira. Isso não é possível sem usar TestNG.
O ESB ( TestNG in Selenium fornece uma opção, ou seja, arquivo testng-failed.xml na pasta test-output. Se você quiser executar apenas casos de teste com falha, significa que você executa 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 de TestNG, como criar métodos de teste usando anotações @test, como converter essas classes em um arquivo de conjunto de testes e executar através do Eclipse e também pela linha de comando.

Por que usar TestNG fazendo o melhor dos nossos Selenium?

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

Os mais Selenium os usuários usam isso mais do que Junito por causa de suas vantagens. Existem tantos recursos de TestNG, mas vamos nos concentrar apenas nos mais importantes que podemos usar em Selenium. A seguir estão as principais características de 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.
O ESB ( TestNG estrutura 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.

TestNG simplifica a maneira 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.

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

Vantagens de TestNG Acima de JUnit

Existem três grandes vantagens TestNG Acima de 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 em 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 @. Muito cedo e rápido TestNG Exemplo é o mostrado abaixo.

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

A capacidade de executar testes em paralelo está disponível em TestNG mas não em JUnit, De modo a TestNG framework é mais preferido para testadores que usam Selenium Rede.

Como escrever casos de teste em TestNG?

Passo 1) Escreva sua lógica de negócios e insira o TestNG anotações 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 TestNG Anotações

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

Antes de criarmos um caso de teste, devemos primeiro configurar um novo TestNG Projeto em Eclipse e nomeie-o como “PrimeiroTestNGProjeto".

Configurando um novo TestNG PROJETO

- Clique em Arquivo > Novo > Java PROJETO

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

- Vamos agora começar a importar o TestNG Bibliotecas em nosso projeto. Clique na guia “Bibliotecas” e depois em “Adicionar Biblioteca…”

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

- Clique em Concluir.

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

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

Em seguida, navegue até onde você colocou o Selenium Arquivos JAR.

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

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

Como criar um novo TestNG Arquivo de teste

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

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

- Selecionar TestNG classe.
Clique no TestNG pasta e selecione o “TestNG opção de classe”. Clique em Avançar.

- Digite os valores.
Digite os valores indicados abaixo nas caixas de entrada apropriadas e clique em Concluir. Observe que nomeamos nosso Java arquivo como “PrimeiroTestNGArquivo".

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

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

Vamos agora criar nosso primeiro Caso de teste isso vai verificar se Mercury A página inicial do Tours está correta. Digite seu código conforme mostrado abaixo TestNG Exemplo:

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 seguinte.

TestNG não requer 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 em TestNG, precisávamos importar o pacote org.testng.annotations.*.
Usamos a classe Assert. A classe Assert é usada para realizar operações de verificação em 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 TestNG arquivo. Isso será abordado com mais detalhes posteriormente na seção “Anotações usadas em 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 TestNG Janela de resultados.

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 o TestNG A janela de resultados nos fornece uma janela gráfica.

Gerando relatórios HTML

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

- Depois de executar nosso primeiroTestNGArquivo que criamos na seção anterior, clique com o botão direito no nome do projeto (PrimeiroTestNGProject) na janela Project Explorer e clique na opção “Atualizar”.

- 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.

- 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.

Anotações usadas em 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 múltiplas anotações @Test em uma única TestNG arquivo. 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.

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

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.

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.

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

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)

@BeforeTest e @AfterTest

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

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 é:

1^st – lançamentoNavegador()
2^nd – verificarHomepageTitle()
3^rd –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 TestNG Exemplo e tente 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

@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.

In Mercury Passeios, suponha que gostaríamos de verificar os títulos das páginas de destino dos dois links abaixo.

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 a seguinte sequência.

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 da TestNG Anotações

@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 quadro capaz de fazer Selenium testes mais fáceis de entender e de gerar relatórios de fácil compreensão.
As principais vantagens de TestNG Acima de JUnit são as seguintes.
- 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 o TestNG A janela é mais útil porque nos fornece uma saída gráfica do resultado do teste, além de outros detalhes significativos, 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 como de costume Java TestNG métodos.
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.

Você pode gostar: