TestNG Tutorial

O que é a TestNG?

TestNG é uma estrutura de testes automatizados onde “NG” significa “Next Generation” (Próxima Geração). TestNG é inspirado por JUnit e usa Java anotações (@) para controlar o fluxo de testes. Isso supera JUnitsuas limitações anteriores e foi projetado para fazer teste de ponta a ponta mais fácil.

Com TestNG Você pode gerar um relatório completo e ver imediatamente quantos testes foram aprovados, reprovados ou ignorados. Você também pode executar novamente apenas os casos em que houve reprovação.

Por exemplo:

• Suponha que você tenha cinco casos de teste, cada um em seu próprio método, escritos sem TestNGTrês testes são bem-sucedidos; o quarto falha. Depois de corrigir o quarto teste, você deseja executar novamente apenas esse teste, já que os três primeiros já foram bem-sucedidos. Isso é difícil de fazer com um código simples do método main().
• TestNG fornece uma testng-failed.xml arquivo no test-output pasta. Executar esse XML reexecuta apenas os casos que falharam.

Além disso, você aprenderá as vantagens de TestNGComo escrever métodos de teste com anotações @Test e como converter suas classes em um conjunto de testes que pode ser executado a partir de Eclipse ou a linha de comando.

Por que usar TestNG com as Selenium?

Por padrão, o Selenium Os testes não produzem resultados bem formatados. TestNG Após ser conectado, o executor de testes gera um relatório estruturado que você pode compartilhar com a equipe.

Os mais Selenium usuários preferem TestNG Acima de JUnit devido ao seu conjunto de recursos mais amplo. Os principais recursos para Selenium como:

• Relatórios que incluem o número de casos de teste executados, aprovados, reprovados e ignorados.
• Grupo fácilping de casos de teste por meio de um testng.xml arquivo, com prioridades de execução.
• Repita um teste várias vezes sem usar loops. invocationCount.
• Execute vários testes em vários navegadores — testes cruzadosteste de navegador .
• Integração perfeita com o Maven, Jenkinse outras ferramentas de CI.
• Readable anotações — por exemplo, @BeforeMethod, @AfterMethod, @BeforeTest, @AfterTest.
• Selenium O WebDriver não possui recursos nativos de geração de relatórios; TestNG Preenche essa lacuna com um relatório HTML limpo como o abaixo.

• TestNG Simplifica o código de teste. Você não precisa mais de um método main estático; as anotações decidem o que é executado e quando.

• Exceções não tratadas são gerenciadas de forma adequada por TestNGSão relatadas como etapas com falha, sem que a execução seja encerrada por completo.

Vantagens de TestNG Acima de JUnit

TestNG oferece três grandes vantagens em relação a JUnit:

• As anotações são mais fáceis de entender e usar.
• Os casos de teste podem ser agrupados e priorizados com menos esforço.
• A execução paralela de testes é suportada nativamente.

O que é uma anotação em TestNG?

Anotações em TestNG São linhas de código colocadas acima de um método para controlar como ele é executado. Eles sempre começam com o símbolo @. Um exemplo simples é mostrado abaixo.

As anotações são abordadas em detalhes na seção “Anotações usadas em TestNG" Mais adiante neste tutorial, portanto, o exemplo acima serve apenas para alinhar as expectativas. TestNG As anotações são mais fáceis de codificar e ler do que os JUnit equivalentes, e são essenciais ao executar testes em Selenium Grade onde a execução paralela é importante.

Como escrever casos de teste em TestNG

Escrevendo um TestNG O caso de teste envolve três etapas:

1. Escreva a lógica do seu negócio e coloque-a no lugar certo. TestNG Anotações acima de cada método.
2. Adicione metadados como nome da classe, nome do grupo e nome do pacote.
3. execute o TestNG classe a partir do seu IDE ou da linha de comando.

Criar um caso de teste usando TestNG Anotações

Agora vamos criar nosso primeiro caso de teste usando TestNG anotações em SeleniumAntes de escrever o teste, configure um novo TestNG projeto em Eclipse e chame isso Primeiro nomeTestNGPROJETO.

Configurando um novo TestNG PROJETO

Passo 1) Clique Arquivo > Novo > Java PROJETO.

Passo 2) Entrar Primeiro nomeTestNGPROJETO como o nome do projeto e clique Seguinte.

Passo 3) Importe o TestNG bibliotecas. Clique no bibliotecas guia e, em seguida Adicionar Biblioteca….

Passo 4) De acordo com o relatório Adicionar biblioteca diálogo, escolha TestNG e clique Seguinte.

Passo 5) Clique Acabamento.

TestNG deverá agora aparecer na lista de Bibliotecas.

Passo 6) Adicione os arquivos JAR que contêm o Selenium API. Estes vêm do Java driver do cliente baixado de selenium.dev/downloads.

Navegue até a pasta onde o Selenium Os arquivos JAR são armazenados.

Após adicionar os arquivos JAR externos, a tela deverá ficar assim.

Passo 7) Clique Acabamento. O novo Primeiro nomeTestNGPROJETO Aparece no Explorador de Pacotes.

Como criar um novo TestNG Arquivo de teste

Com o projeto pronto, crie um novo TestNG arquivo.

Passo 1) Clique com o botão direito do mouse no src pasta e escolha Novo > Outros….

Passo 2) Expandir o TestNG pasta, selecione TestNG classeE clique Seguinte.

Passo 3) Insira os valores mostrados abaixo e clique em Acabamento. O Java arquivo é nomeado Primeiro nomeTestNGEnvie o.

Passo 4) Eclipse gera o TestNG Modelo mostrado abaixo.

Programando seu primeiro TestNG Caso de teste

Crie o primeiro caso de teste que verifica o título do Mercury Página inicial de passeios.

package firsttestngpackage;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.Test;

public class FirstTestNGFile {

    public String baseUrl = "https://demo.guru99.com/test/newtours/";
    public WebDriver driver;

    @Test
    public void verifyHomepageTitle() {
        System.out.println("launching firefox browser");
        // Selenium 4 ships Selenium Manager, so the driver path is no longer required.
        driver = new FirefoxDriver();
        driver.get(baseUrl);
        String expectedTitle = "Welcome: Mercury Tours";
        String actualTitle = driver.getTitle();
        Assert.assertEquals(actualTitle, expectedTitle);
        driver.quit();
    }
}

Coisas a observar:

• TestNG não precisa de um main() método.
• Os métodos não precisam ser estáticos.
• O @Teste marcas de anotação verifyHomepageTitle() como um caso de teste.
• As anotações ficam armazenadas no org.testng.annotations.* pacote.
• O Afirmar classe de org.testng.Assert verificações de unidades.

Você pode ter várias anotações @Test em uma única anotação. TestNG arquivo. Abordamos isso no “Anotações usadas em TestNG" seção.

Executando o teste

Clique com o botão direito do mouse no arquivo e execute-o como um TestNG teste. Eclipse produz duas saídas — um resultado em texto na janela do Console e um resultado gráfico no TestNG Janela de resultados.

Verificando relatórios criados por TestNG

A janela do Console fornece um resumo baseado em texto, enquanto o TestNG A janela de resultados exibe uma visualização gráfica.

Gerando relatórios HTML

TestNG Também pode gerar relatórios HTML completos.

Passo 1) Depois de correr Primeiro nomeTestNGEnvie o, clique com o botão direito do mouse no projeto e escolha revisar.

Passo 2) A saída de teste A pasta aparecerá. Expanda-a e localize index.html — o relatório HTML da execução mais recente.

Passo 3) Double-clique index.html para abri-lo por dentro Eclipsenavegador. Pressione F5 para atualizar após execuções futuras.

Anotações usadas em TestNG

Você já viu a anotação @Test. O restante desta seção aborda as anotações avançadas mais úteis.

Vários casos de teste

Uma única TestNG Um arquivo pode conter várias anotações `@Test`. Por padrão, os métodos anotados com `@Test` são executados em ordem alfabética. No código abaixo, os métodos c_test, a_test e b_test Executar em ordem alfabética, independentemente da ordem de origem.

Execute o código e abra index.html. Clique Visão cronológica.

Parâmetros Técnicos

Para substituir a ordem padrão, use o priority parâmetro. Os parâmetros são palavras-chave que modificam o comportamento de uma anotação.

• Atribua um valor com =.
• Coloque os parâmetros entre parênteses imediatamente após a anotação, como mostrado abaixo.

TestNG Executa as anotações @Test da prioridade mais baixa para a mais alta. Os números de prioridade não precisam ser consecutivos.

O relatório HTML confirma que os métodos foram executados em ordem crescente de prioridade.

Parâmetros múltiplos

Além de priority, @Test aceita o alwaysRun parâmetro (verdadeiro ou falso). Para usar dois ou mais parâmetros em uma única anotação, separe-os com uma vírgula:

@Test(priority = 0, alwaysRun = true)

@BeforeTest e @AfterTest

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

Considere o código abaixo.

package firsttestngpackage;

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

public class FirstTestNGFile {

    public String baseUrl = "https://demo.guru99.com/test/newtours/";
    public WebDriver driver;

    @BeforeTest
    public void launchBrowser() {
        System.out.println("launching firefox browser");
        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.quit();
    }
}

A partir da tabela e do código, podemos prever que a sequência será:

• 1º — launchBrowser()
• 2º — verifyHomepageTitle()
• 3º — terminateBrowser()

A posição dos blocos de anotação no arquivo fonte não afeta a ordem de execução. Tente reorganizar os métodos conforme mostrado abaixo.

package firsttestngpackage;

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

public class FirstTestNGFile {

    public String baseUrl = "https://demo.guru99.com/test/newtours/";
    public WebDriver driver;

    @AfterTest                              // Jumbled
    public void terminateBrowser() {
        driver.quit();
    }

    @BeforeTest                             // Jumbled
    public void launchBrowser() {
        System.out.println("launching firefox browser");
        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 e verifique o resultado.

@BeforeMethod e @AfterMethod

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

In Mercury Em "Tours", suponhamos que desejamos verificar os títulos de duas páginas de destino acessadas a partir da página inicial.

O fluxo do teste é o seguinte:

• Abra a página inicial e verifique o título.
• Clique em CADASTRE-SE e verifique o título da página de destino.
• Volte à página inicial e verifique o título.
• Clique em APOIO e verifique o título da página de destino.
• Volte à página inicial e verifique o título novamente.

O código abaixo mostra como @BeforeMethod e @AfterMethod lidam com as etapas repetidas.

package firsttestngpackage;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;

public class FirstTestNGFile {

    public String baseUrl = "https://demo.guru99.com/test/newtours/";
    public WebDriver driver;
    public String expected = null;
    public String actual = null;

    @BeforeTest
    public void launchBrowser() {
        System.out.println("launching firefox browser");
        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.quit();
    }
}

Após executar o teste, TestNG A sequência apresentada é a seguinte.

Resumindo: coloque as etapas de configuração dentro @BeforeMethod e limpeza ou reinicialização da navegação interna @AfterMethod Assim, cada caso de teste começa e termina em um estado conhecido.

Resumo da TestNG Anotações

• @BeforeSuite: É executado antes de todos os testes do conjunto.
• @AfterSuite: É executado após todos os testes do conjunto.
• @AntesDoTeste: é executado antes de qualquer método de teste pertencente às classes dentro de um marcação.
• @AfterTest: executa após todos os métodos de teste pertencentes às classes dentro de um marcação.
• @BeforeGroups: É executado logo antes do primeiro método de teste que pertence a qualquer grupo listado.
• @AfterGroups: É executado logo após o último método de teste que pertence a qualquer grupo listado.
• @AntesDaAula: É executado antes do primeiro método de teste na classe atual.
• @AfterClass: É executado após todos os métodos de teste na classe atual.
• @BeforeMethod: Executa antes de cada método de teste.
• @AfterMethod: Executa após cada método de teste.
• @Teste: marca o método como um caso de teste.

Perguntas Frequentes