Tutorial do TestNG: O que é, Anotações & Estrutura em Selenium

Índice:

Anonim

O que é TestNG?

TestNG é uma estrutura de teste de automação em que NG significa "Próxima Geração". TestNG é inspirado no JUnit, que usa as anotações (@). O TestNG supera as desvantagens do JUnit e é projetado para facilitar o teste de ponta a ponta.

Usando TestNG, você pode gerar um relatório adequado e pode facilmente saber 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 pela primeira vez, três métodos são executados com êxito 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 sucesso de qualquer maneira. Isso não é possível sem usar TestNG.
  • O TestNG no Selenium oferece uma opção, ou seja, o arquivo testng-failed.xml na pasta de saída de teste. Se você deseja executar apenas casos de teste com falha, significa que você deve executar 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 suíte de teste e executar através do eclipse, bem como da linha de comando .

Neste tutorial do TestNG, você aprenderá

  • Por que usar TestNG com selênio?
  • Vantagens do TestNG em relação ao JUnit
  • Criar caso de teste usando anotações TestNG
  • Como criar um novo arquivo de teste TestNG
    • Codificação do nosso primeiro exemplo de caso de teste TestNG
    • Executando o Teste
  • Verificando relatórios criados por TestNG
  • Anotações usadas no TestNG
  • Casos de teste múltiplos
  • Parâmetros
    • Parâmetros Múltiplos
    • Resumo das anotações TestNG

Por que usar TestNG com selênio?

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

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

  • Gere o relatório em um formato adequado, incluindo várias execuções de casos de teste, o número de casos de teste aprovados, o número de casos de teste que falharam e o número de casos de teste ignorados.
  • Vários casos de teste podem ser agrupados mais facilmente, convertendo-os em um arquivo testng.xml. No qual você pode estabelecer prioridades que 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ção'.
  • Usando testng, você pode executar vários casos de teste em vários navegadores, ou seja, teste de navegador cruzado.
  • O framework TestNG pode ser facilmente integrado com ferramentas como TestNG Maven, Jenkins, etc.
  • As anotações usadas no teste são muito fáceis de entender, ex: @BeforeMethod, @AfterMethod, @BeforeTest, @AfterTest
  • O WebDriver não possui mecanismo nativo para gerar 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 pelo TestNG sem encerrar o teste prematuramente. Essas exceções são relatadas como etapas com falha no relatório.

Vantagens do TestNG em relação ao JUnit

Existem três vantagens principais do TestNG em relação ao JUnit:

  • As anotações são mais fáceis de entender
  • Os casos de teste podem ser agrupados mais facilmente
  • O teste paralelo é possível

As anotações no 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 inicial e rápido é o mostrado abaixo.

As anotações serão discutidas posteriormente na seção chamada "Anotações usadas no TestNG", portanto, está perfeitamente ok se você ainda não entender o exemplo 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 dos testadores que usam Selenium Grid.

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 criar um caso de teste, devemos primeiro configurar um novo Projeto TestNG no Eclipse e nomeá-lo como "FirstTestNGProject".

Configurando um novo projeto TestNG

Etapa 1: Clique em Arquivo> Novo> Projeto Java

Etapa 2: Digite "FirstTestNGProject" como o nome do projeto e clique em Avançar.

Etapa 3: agora começaremos a importar as bibliotecas TestNG para o nosso projeto. Clique na guia "Bibliotecas" e depois em "Adicionar biblioteca

… "

Etapa 4: Na caixa de diálogo Adicionar biblioteca, escolha "TestNG" e clique em Avançar.

Etapa 5: Clique em Concluir.

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

Etapa 6: Agora adicionaremos os arquivos JAR que contêm a API Selenium. Esses arquivos são encontrados no driver cliente Java que baixamos de http://docs.seleniumhq.org/download/ quando estávamos instalando o Selenium e o Eclipse nos capítulos anteriores.

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

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

Etapa 7: Clique em Concluir e verifique se nosso FirstTestNGProject está visível na janela Package Explorer do Eclipse.

Como criar um novo arquivo de teste TestNG

Agora que configuramos nosso projeto neste tutorial TestNG, vamos criar um novo arquivo TestNG.

Etapa 1: clique com o botão direito na pasta do pacote "src" e escolha Novo> Outro

…

Etapa 2: Clique na pasta TestNG e selecione a opção "Classe TestNG". Clique em Avançar.

Etapa 3: Digite os valores indicados abaixo nas caixas de entrada apropriadas e clique em Concluir. Observe que nomeamos nosso arquivo Java como "FirstTestNGFile".

O Eclipse deve criar automaticamente o modelo para nosso arquivo TestNG mostrado abaixo.

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

Vamos agora criar nosso primeiro caso de teste que 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";driver público do WebDriver;@Testepublic void verifyHomepageTitle () {System.out.println ("iniciando o navegador firefox");System.setProperty ("webdriver.gecko.driver", driverPath);driver = novo FirefoxDriver ();driver.get (baseUrl);StringesperadoTitle = "Bem-vindo: Mercury Tours";String actualTitle = driver.getTitle ();Assert.assertEquals (actualTitle, expectedTitle);driver.close ();}}

Observe o seguinte.

  • 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 dizer que o método sob ele é um caso de teste . Nesse caso, definimos o método verifyHomepageTitle () para ser nosso caso de teste, então colocamos uma anotação '@Test' acima dele.
  • Como usamos anotações no TestNG, precisamos 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 posteriormente na seção "Anotações usadas no TestNG."

Executando o Teste

Para executar o teste, simplesmente execute o arquivo no Eclipse como você normalmente faz. O Eclipse fornecerá duas saídas - uma na janela do console e a outra na janela TestNG Results.

Verificando relatórios criados por TestNG

A janela do console no Eclipse fornece um relatório baseado em texto de nossos resultados de caso de teste, enquanto a janela TestNG Results fornece um gráfico.

Gerando relatórios HTML

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

Etapa 1: Depois de executar nosso FirstTestNGFile que criamos na seção anterior, clique com o botão direito do mouse no nome do projeto (FirstTestNGProject) na janela Project Explorer e clique na opção "Atualizar".

Etapa 2: observe que uma pasta de "saída de teste" foi criada. Expanda-o e procure um arquivo index.html. Este arquivo HTML é um relatório dos resultados do teste mais recente.

Etapa 3: clique duas vezes no arquivo index.html para abri-lo no navegador da web integrado do Eclipse. Você pode atualizar esta página a qualquer momento depois de executar o teste novamente, simplesmente pressionando F5, como em navegadores comuns.

Anotações usadas no TestNG

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

Casos de teste múltiplos

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.

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

Parâmetros

Se você deseja que os métodos sejam executados em uma ordem diferente, use 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, em seguida, 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 relatório HTML do TestNG 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 a mostrada abaixo.

@Test (prioridade = 0, alwaysRun = true)

@BeforeTest e @AfterTest

@BeforeTest

métodos sob esta anotação serão executados antes do primeiro caso de teste no arquivo TestNG .

@AfterTest

os 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";driver público do WebDriver;@BeforeTestpublic void launchBrowser () {System.out.println ("iniciando o navegador firefox");System.setProperty ("webdriver.gecko.driver", driverPath);driver = novo FirefoxDriver ();driver.get (baseUrl);}@Testepublic void verifyHomepageTitle () {StringesperadoTitle = "Bem-vindo: Mercury Tours";String actualTitle = driver.getTitle ();Assert.assertEquals (actualTitle, expectedTitle);}@AfterTestpublic void terminateBrowser () {driver.close ();}}

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

  • 1 r - launchBrowser ()
  • 2 ° - verifyHomepageTitle ()
  • 3 rd - terminateBrowser ()

A colocação dos blocos de anotação pode ser trocada sem afetar a ordem cronológica em que serão executados . Vamos entender com um exemplo TestNG e tentar reorganizar os blocos de anotação de forma que seu código fique parecido com o 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";driver público do WebDriver;@AfterTest // Jumbledpublic void terminateBrowser () {driver.close ();}@BeforeTest // Jumbledpublic void launchBrowser () {System.out.println ("iniciando o navegador firefox");System.setProperty ("webdriver.gecko.driver", driverPath);driver = novo FirefoxDriver ();driver.get (baseUrl);}@Test // Jumbledpublic void verifyHomepageTitle () {StringesperadoTitle = "Bem-vindo: Mercury Tours";String actualTitle = driver.getTitle ();Assert.assertEquals (actualTitle, expectedTitle);}}

Execute o código acima e observe que

@BeforeMethod e @AfterMethod

@BeforeMethod

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

Em Mercury Tours, suponha que gostamos 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 o título.
  • Clique em REGISTAR e verifique o título de sua página de destino.
  • Volte para a página inicial e verifique se ainda tem o título correto.
  • Clique em SUPORTE e verifique o título de sua página de destino.
  • Volte para a página inicial e verifique se ainda tem o título correto.

O código a seguir 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. *;@Testepublic class firsttestngfile {public String baseUrl = "http://demo.guru99.com/test/newtours/";String driverPath = "C: \\ geckodriver.exe";driver público do WebDriver;público String esperado = nulo;public String real = null;@BeforeTestpublic void launchBrowser () {System.out.println ("iniciando o navegador firefox");System.setProperty ("webdriver.gecko.driver", driverPath);driver = novo FirefoxDriver ();driver.get (baseUrl);}@BeforeMethodpublic void verifyHomepageTitle () {StringesperadoTitle = "Bem-vindo: Mercury Tours";String actualTitle = driver.getTitle ();Assert.assertEquals (actualTitle, expectedTitle);}@Test (prioridade = 0)public void register () {driver.findElement (By.linkText ("REGISTER")). click ();esperado = "Registrar: Mercury Tours";real = driver.getTitle ();Assert.assertEquals (real, esperado);}@Test (prioridade = 1)public void support () {driver.findElement (By.linkText ("SUPPORT")). click ();esperado = "Em construção: Mercury Tours";real = driver.getTitle ();Assert.assertEquals (real, esperado);}@AfterMethodpublic void goBackToHomepage () {driver.findElement (By.linkText ("Home")). click ();}@AfterTestpublic 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 de cada caso de teste, enquanto @AfterMethod deve conter métodos que você precisa para executar após cada caso de teste.

Resumo das anotações TestNG

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

@BeforeTest : O método anotado será executado antes que qualquer método de teste pertencente às classes dentro da tag seja executado.

@AfterTest : O método anotado será executado depois que todos os métodos de teste pertencentes às classes dentro da tag forem executados.

@BeforeGroups : A lista de grupos que este método de configuração irá executar antes. A execução desse método é garantida logo antes de o primeiro método de teste pertencente a qualquer um desses grupos ser chamado.

@AfterGroups : A lista de grupos após os quais este método de configuração será executado. A execução desse método é garantida logo após a chamada do último método de teste pertencente a qualquer um desses grupos.

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

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

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

Conclusão

  • TestNG é uma estrutura de teste capaz de tornar os testes Selenium mais fáceis de entender e de gerar relatórios que são fáceis de entender.
  • As principais vantagens do TestNG em relação ao 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 do console no 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 mais 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 os métodos Java TestNG usuais.
  • TestNG Dataprovider é uma maneira de passar parâmetros para a função de teste que passa valores diferentes em casos de teste em uma única execução.