Menu

Anotações e ouvintes do TestNG

testng annotations listeners

Experimente Nosso Instrumento Para Eliminar Problemas

Este tutorial explica os diferentes tipos de anotações e ouvintes do TestNG. Você também aprenderá a usar as anotações e ouvintes do TestNG com exemplos:

Aqui, executaremos um programa TestNG básico usando anotações TestNG e também veremos a função dos Ouvintes TestNG e como usá-los nos testes.

=> Leia a série de treinamento Easy TestNG.

Anotações e ouvintes do TestNG

O que você aprenderá:

O que são anotações TestNG?

Estes são os programas ou lógicas de negócios usados ​​para controlar o fluxo de métodos. Eles desempenham um papel muito importante no TestNG. Essas anotações diferem em cada projeto de acordo com os requisitos. O fluxo de anotações permanece o mesmo em todos os programas, apesar dos diferentes requisitos.

Existem diferentes tipos de anotações TestNG que tornam o TestNG mais fácil e melhor do que JUnit. Cada uma dessas anotações será executada em um evento específico no TestNG.

Tipos de anotações em TestNG

Dada a seguir, estão as listas de anotações e seus atributos que são usados ​​no TestNG. Vamos explorá-los e seus usos em detalhes.

Antes

  • @BeforeSuite: Este método será executado antes que todos os testes da suíte sejam executados.
  • @BeforeTest: Este método será executado antes que cada seção de teste seja declarada no conjunto.
  • @Antes da aula: Este método será executado antes do primeiro método de teste na classe atual.
  • @BeforeMethod: Este método será executado antes de cada método de teste.
  • @BeforeGroups: Este método será executado antes que qualquer método de teste do grupo especificado seja mencionado.
  • @Teste : Marca uma classe ou método como parte do teste. Ou podemos dizer que faz um método como método de teste.

Depois de

  • @AfterSuite: Este método será executado depois que todos os testes da suíte forem executados.
  • @AfterTest: Este método será executado após cada seção de teste ser declarada no conjunto.
  • @Depois da aula: Este método será executado após o último método de teste da classe.
  • @AfterMethod: Este método será executado após a execução de cada método de teste.
  • @AfterGroups: Este método será executado após o último método de teste do grupo especificado ser executado.

Fluxo de trabalho de anotações

Quando executamos o arquivo TestNG.xml, as anotações TestNG serão executadas na seguinte sequência:

Antes da Suíte-> Antes do Teste-> Antes da Aula-> Método Antes-> @Test -> Após o Método-> Depois da Aula-> Após o Teste-> Após a Suíte

@BeforeSuite @BeforeTest @BeforeClass @BeforeMethod @Test @AfterMethod @AfterClass @AfterTest @AfterSuite

@Teste tem muitos outros atributos que nos ajudam a executar nossos casos de teste com mais eficácia.

Abaixo estão os tipos de atributos e suas descrições com exemplos.

# 1) alwaysRun: Quando definido como verdadeiro, esse método será executado mesmo se depender de um método que falhou.

Exemplo: Teste (alwaysRun = true)

# 2) dataProvider : Mostra o nome do provedor de dados para este método. Possui apenas atributos, ou seja, nome. Podemos usá-lo quando testamos nosso software com vários conjuntos de dados em tempo de entrada ou tempo de execução. Isso também é conhecido como teste baseado em dados. Podemos fazer testes baseados em dados usando este atributo.

Exemplo: @dataProvider (name = ”TestData”)

# 3) dataProviderClass : Este atributo permitirá que você especifique a classe do provedor de dados que conterá o provedor de dados que o método @Test usará.

Exemplo: @Test (dataProvider = “Client Data Test”, dataProviderClass = ClientDetailsTest.class)

# 4) dependsOnGroups : Este atributo depende da lista de grupos, ou seja, o método de teste iniciará a execução somente depois que os grupos dependentes forem executados.

Observação : Se algum dos testes dos grupos dependentes falhar, ele ignorará esse teste.

Abaixo está o exemplo:

@Test(groups= “homepage”) public void homepageTest(){ System.out.println('Home Page displayed successfully'); } @Test(groups= “transactionspage”) Public void transactionpageTest(){ System.out.println(“Transaction Page displayed successfully”); } @Test(dependsOnGroups={“homepage”, “transactionspage”}) public void dependOnGroupTest1(){ System.out.println(“dependency tested successful”);

# 5) dependsOnMethods : Esta anotação depende da lista de métodos. Isso significa que o método de teste iniciará a execução somente depois que os métodos dependentes forem executados.

Observação : Se algum dos testes nos métodos dependentes falhar, ele ignorará esse teste.

Exemplo:

@Test public void loginTest() { System.out.println(“Login Tested Successfully”); } @Test public void homepageTest() { System.out.println(“Home Page Tested Successfully”); } @Test(dependsOnMethods={“ loginTest”, “homepageTest”}) public void smokeTest() { System.out.println(“Smoke Tests were done successfully”);

# 6) alwaysRun = true: Podemos definir os atributos em um método de teste como verdadeiros, e isso forçará a execução do teste, mesmo se alguns dos testes no grupo dependerem de falhas.

Por exemplo:

@Test public void launchAppTest() { System.out.println(“Application launched Successfully”); } @Test public void loginAppTest() { System.out.println(“Application logged in Successfully”); } @Test(dependsOnMethods={“launchAppTest”, “loginAppTest”}, alwaysRun=true) public void smokeTest() { System.out.println(“Smoke Test were done successfully”); }

# 7) descrição : Fornece a descrição do método. Geralmente, contém um resumo de uma linha.

Exemplo:

@Test(description = “Regression Test Summary”)

# 8) habilitado : Este atributo ajuda a especificar se queremos rodar / executar o método de teste particular na suíte / classe atual ou não. Às vezes, não queremos executar alguns testes devido a alguns motivos, como o requisito / função muda com frequência e não queremos perturbar a execução atual para essa função específica.

Nesses casos, podemos simplesmente ignorar / desabilitar esse teste específico configurando esse recurso como @Test (enabled = false).

Exemplo:

@Test(enabled = false) public void imageTest() {//We have disabled this test by giving enabled=false System.out.println(“Image was tested successfully()”); }

# 9) Exceções esperadas : Este atributo mostra a lista de exceções que o método de teste irá lançar no tempo de execução. Se nenhuma exceção ou qualquer outra exceção for lançada para o método, o teste será marcado como uma falha.

Exemplo:

@Test(expectedExceptions = ArithmeticException.class) public void numericTest() { int i = 1 / 0; }

# 10) grupos : Este atributo é usado para especificar os grupos aos quais o método de teste pertence.

@Test(groups = {“Regression”}) Public void runRegressionTest(){ System.out.println(“test runs were successful”); }

# 11) prioridade : Isso ajuda a priorizar os métodos de teste, enquanto a prioridade padrão começa com 0 e os testes são executados em ordem crescente.

Exemplo:

@Test Public void launchApp(){ System.out.println(“Application was launched successfully”): } @Test (priority = 1) Public void loginApp(){ System.out.println(“Application logged in successfully”); } @Test (priority = 2) Public void checkTrans(){s System.out.println(“Checked Transactions successfully”); }

Resultados: Abaixo estão os resultados por prioridade, embora nenhum número tenha sido atribuído ao primeiro teste, ele teve sua prioridade por padrão como 0 e a execução foi feita em ordem crescente.

Aprovado: launchApp
Aprovado: loginApp
Aprovado: checkTrans

# 12) tempo limite : Este atributo ajuda a especificar um valor de tempo limite para o teste (geralmente usado como milissegundos). Se o teste demorar mais do que o valor de tempo limite especificado, o teste será marcado como reprovado. Podemos usar esse tempo limite para fazer um teste de desempenho, para ter certeza de que o método está retornando dentro de um tempo razoável.

@Test(timeOut = 500) public void timeTest() throws InterruptedException { Thread.sleep(400); System.out.println(“Time test method successfully tested”); }

# 13) invocationCount : Este atributo ajuda a determinar o número de vezes que um método de teste deve ser chamado.

@Test(invocationCount = 5) public void loginTest() { WebDriver driver = new FirefoxDriver(); driver.get('http://www.google.com'); System.out.println('Page Title is ' + driver.getTitle()); driver.quit();

Resultado:

O título da página é Google
O título da página é Google
O título da página é Google
O título da página é Google
O título da página é Google

# 14) invocationTimeOut: Este é o tempo máximo (nº de milissegundos) que este teste deve levar para todas as contagens de invocação. Este método deve ser usado junto com o método de contagem de invocação ou então ele seria ignorado.

Exemplo:

@Test(invocationCount=4, invocationTimeOut=4000) public void loginTest(){ Thread.sleep(1000); System.Out.println(“login Test”); }

O exemplo acima mostra que este teste levará um total de 4 segundos para ser executado e cada vez que o teste for chamado / executado, levará 1 segundo para ser executado.

# 15) @DataProvider : Este método ajuda a fornecer dados para um método de teste. Primeiro, temos que declarar um método anotado por @DataProvider e então usar este método no método de teste requerido usando o atributo “DataProvider” na anotação @Test.

Um provedor de dados retorna uma matriz de objetos, especialmente uma matriz de objeto bidimensional () (). O primeiro array representa um conjunto de dados e o segundo array contém os parâmetros.

@DataProvider (name = “Test”) - Aqui, o nome representa o nome do Provedor de Dados. Se o nome não for fornecido, o nome do DataProvider será automaticamente definido como o nome do método.

Exemplo:

@DataProvider(name = “Name”) public object()() credentials(){ return new object ()() { { “Mohan”, “23”}, { “Shikhar”, “30”} }; } //Now we are calling the Data Provider object by its name @Test(DataProvider = “Name”) Public void testData(String sName, int age) { System.out.println(“Data is: (Name, age)”); }

# 16) @Factory : Isso é usado para especificar um método como uma fábrica para fornecer objetos que devem ser usados ​​por TestNG para suas classes de teste. Usando @Factory, podemos criar testes dinâmicos em tempo de execução e ele deve retornar um objeto array.

Exemplo:

Vamos dar um exemplo para entender melhor. Vamos criar duas classes, ou seja, FactorySample.Java e FactoryTest.Java

FactorySample.Java

public class FactorySample { @Test public void googleTest() { System.out.println(“Google was launched successfully”); } @Test public void gmailLogin() { System.out.println(“Gmail logged in successfully”); }

FactoryTest.Java

public class FactoryTest { @Factory() public Object() testFact() { FactorySample fs = new FactorySample(2); fs(0) = new googleTest(); fs(1) = new gmailLogin(); return fs; } }

Resultado : Google foi lançado com sucesso

Gmail conectado com sucesso

Diferença entre as anotações @Factory e @DataProvider

Existe uma diferença básica entre as duas anotações. Há muita confusão em relação a essas duas anotações, como onde usá-las e por quê?

Vamos encontrar as respostas.

@DataProvider: Esta anotação irá parametrizar o método de teste particular e executar o teste em um nº específico. de vezes com base nos dados fornecidos por este método.

Por exemplo, se houver dois parâmetros, o método de teste será executado duas vezes. Por exemplo, se quisermos fazer o login em um site com diferentes conjuntos de nomes de usuário e senhas a cada vez, isso é útil, pois temos que fornecer os parâmetros para teste.

@Fábrica : Isso executará todos os métodos de teste presentes no arquivo de classe de teste ao usar uma instância separada dessa classe. Isso é útil se quisermos executar a classe de teste várias vezes.

Por exemplo , se tivermos que testar a função de login de qualquer aplicativo ou site e como tivermos que executar esse teste várias vezes, é melhor usar @Factory, onde podemos criar várias instâncias de teste e executar os testes.

Vamos dar uma olhada nesses exemplos para saber a diferença.

@DataProvider Exemplo :

@DataProvider public Object()() message(){ return new Object ()(){{“Mihir” , new Integer (145632)}, {“Kumar”, new Integer (28242)}}; } @Test (dataProvider=”message”) public void PrintMsg(String name, Integer id){ System.out.println(“Names are: “+name+” “+id); }

Observação : No programa acima, fornecemos dois dados e o resultado do programa seria:

Os nomes são: Mihir 145632
Os nomes são: Kumar 28242

Isso mostra que, se aumentarmos o número de dados no método de mensagem, o método de impressão será executado o mesmo número de vezes.

Exemplo @Factory :

TestNG Factory é muito útil quando temos que executar várias classes de teste usando uma única classe de teste.

Vamos ver um exemplo.

Para isso, temos que criar duas classes de teste com poucos métodos de teste dentro delas.

TestData 1:

public class TestData1 { @Test public void testData1() { System.out.println('Test data 1 successfully tested'); } }

TestData 2:

public class TestData2 { @Test public void testData2() { System.out.println('Test data 2 successfully tested'); } }

Agora temos que definir o método @Factory que retorna um array de objetos das classes definidas acima.

Programa de fábrica:

public class TestNGFactory { @Factory() public Object() getTestClass() { Object() tests = new Object(2); tests(0) = new Test Data 1(); tests(1) = new Test Data 2(); return tests; } }

Resultado:

Método de teste Test1
Método de teste Test2
APROVADO: test1
APROVADO: test2

Ouvintes TestNG com tipos

Em termos simples, os Ouvintes ouvem o evento definido no script Selenium e se comportam de acordo com ele. O objetivo principal é criar logs e personalizar os relatórios TestNG.

Existem muitos tipos de ouvintes disponíveis no TestNG.

Por exemplo , IAnnotationTransformer, IAnnotationTransformer2, IConfigurable, IConfigurationListener, IConfigurationListener2, IExecutionListener, IHookable, IInvokedMethodListener, IInvokedMethodListener2, IMethodInterceptor, IReporter, ISuiteListener,

No entanto, quando se trata de testes, usamos apenas alguns deles, conforme discutido abaixo:

# 1) ISuiteListener

Este é um ouvinte para suítes de teste. Consiste em dois métodos, ou seja, onStart () e onFinish () .

Sempre que implementarmos esse ouvinte, isso garantirá que o usuário final invoque os métodos onStart () e onFinish () antes e depois de executar um conjunto TestNG.

Detalhes do método:

void onStart (suíte ISuite) : Este método é invocado antes que o Suite Runner seja iniciado.

void onFinish (suíte ISuite) : Este método é chamado depois que o Suite Runner executa todos os conjuntos de testes.

Exemplo:

@Override public void onStart(ISuite suite) { System.out.println(“TestNG Suite Starts”); } @Override public void onFinish(ISuite suite) { System.out.println(“TestNG Suite Finishes”); }

# 2) ITestListener

Este ouvinte funciona exatamente como o ISuiteListener. Porém, a única diferença é que ele faz a ligação antes e depois do Teste e não da Suite. É um ouvinte para execução de teste e esse ouvinte possui sete métodos.

(i) onStart () :Este método é chamado depois que a classe de teste é instanciada e antes que qualquer método de configuração seja chamado.

Exemplo:

@Override public void onStart(ITestContext context) { System.out.println(“Context Name = ” + context.getName()); }

(ii) onFinish () :Este método é invocado depois que todos os testes são executados e todos os métodos de configuração são chamados.

Exemplo:

public void onFinish(ITestContext context) { System.out.println(context.getPassedTests()); }

(iii) onTestStart () :Este método é invocado todas as vezes antes de um teste ser invocado. O ITestResult é apenas parcialmente preenchido com as referências à classe, método, milis de início e status.

Método: void onTestStart (resultado ITestResult)

Exemplo:

@Override public void onTestStart(ITestResult result) { System.out.println('Test Started…'+result.getStartMillis()); }

(iv) onTestSuccess () :Este método é invocado sempre que um teste é bem-sucedido.

Método: void onTestSuccess (resultado de ITestResult)

Exemplo:

@Override public void onTestSuccess(ITestResult result) { System.out.println('Test Success. '+result.getEndMillis()); }

(v) onTestFailure () :Este método é invocado sempre que um teste falha.

Método: void onTestFailure (resultado ITestResult)

Exemplo:

@Override public void onTestFailure(ITestResult result) { System.out.println('Test Failed. '+result.getTestName()); }

(vi) onTestSkipped () :Este método é chamado sempre que um teste é ignorado.

Método: void onTestSkipped (resultado de ITestResult)

Exemplo:

@Override public void onTestSkipped(ITestResult result) { System.out.println('Test Skipped. '+result.getTestName()); }

(vii) onTestFailedButWithinSuccessPercentage :Este método é chamado sempre que um método falha, mas foi anotado com a porcentagem de sucesso e a falha o mantém dentro da porcentagem de sucesso.

Método: void onTestFailedButWithinSuccessPercentage (resultado de ITestResult)

Exemplo:

@Override public void onTestFailedButWithinSuccessPercentage(ITestResult iTestResult) { System.out.println('Test failed but it is in defined success ratio ' + getTestMethodName(iTestResult)); }

# 3) IExecutionListener

É um ouvinte que monitora o início e o fim de uma execução do TestNG. Tem dois métodos, ou seja, onExecutionStart () e onExecutionFinish () .

O método onExecutionStart () é chamado antes que o TestNG comece a executar os conjuntos e o método onExecutionFinish () é chamado depois que TestNG é concluído com a execução de todos os conjuntos de teste.

Método:

void onExecutionStart ()

void onExecutionFinish ()

Exemplo:

@Override public void onExecutionStart() { System.out.println('TestNG is going to start'); } @Override public void onExecutionFinish() { System.out.println('TestNG is finished'); }

# 4) IInvokedMethodListener

É um ouvinte que é chamado antes e depois de um método ser chamado por TestNG. Este ouvinte é chamado apenas para configurações e métodos de teste. Possui apenas dois métodos, ou seja, afterInvocation e beforeInvocation.

  1. antes do convite: Invoque antes de cada método.
  2. afterInvocation: Chame após cada método.

Método:

void beforeInvocation (método IInvokedMethod, ITestResult testResult)

void afterInvocation (método IInvokedMethod, ITestResult testResult)

Exemplo:

@Override public void beforeInvocation(IInvokedMethod method, ITestResult testResult) { System.out.println('before invocation of ' + method.getTestMethod().getMethodName()); } @Override public void afterInvocation(IInvokedMethod method, ITestResult testResult) { System.out.println('after invocation of ' + method.getTestMethod().getMethodName()); }

# 5) IMethodInterceptor

Esta classe é usada para alterar a lista de métodos de teste que TestNG vai executar. Usando este método, podemos reordenar a lista de métodos de teste.

É aplicável apenas aos métodos que não têm dependentes e os métodos que não dependem de nenhum outro método de teste serão passados ​​em parâmetros. Essa interface retornará uma lista de métodos de teste que precisam ser executados, mas de uma maneira diferente de classificação.

Método:

qual é o melhor programa para limpar seu computador

interceptação java.util.List (métodos java.util.List, contexto ITestContext)

Exemplo:

@Override public Listintercept(Listmethods, ITestContext context) { List result = new ArrayList(); for (IMethodInstance m : methods) { Test test = m.getMethod().getMethod().getAnnotation(Test.class); Setgroups = new HashSet(); for (String group : test.groups()) { groups.add(group); } if (groups.contains('sanity')) { result.add(m); } else { String testMethod = m.getMethod().getMethodName(); System.out.println(testMethod + ' not a SANITY test so not included'); } } return result; }

# 6) IReporter

Isso é implementado pelos clientes para gerar um relatório. Este método será chamado assim que todo o conjunto for executado e os parâmetros fornecerem todos os resultados de teste que aconteceram durante aquela execução.

Método:

void generateReport (java.util.List xmlSuites, java.util.List suites, java.lang.String outputDirectory)

Exemplo:

@Override public void generateReport(List xmlSuites, List suites, String outdir) { try { writer = createWriter(outdir); } catch (IOException e) { System.err.println('Unable to create output file'); e.printStackTrace(); return; } startHtml(writer); writeReportTitle(reportTitle); generateSuiteSummaryReport(suites); generateMethodSummaryReport(suites); generateMethodDetailReport(suites); endHtml(writer); writer.flush(); writer.close(); }

Conclusão

Neste artigo, vimos como as anotações TestNG podem ser úteis para tornar a lógica do nosso programa mais fácil. As anotações são usadas conforme necessário.

Você pode passar os parâmetros para as anotações e também fazer testes orientados a dados. Você pode executar os casos de teste em grupos e economizar tempo. Com ouvintes, você pode até gerar os relatórios. Você não acha que isso é maravilhoso?

TestNG.xml será explicado em detalhes em nosso próximo tutorial. Este arquivo XML é a espinha dorsal da estrutura TestNG e nos ajudará na execução de nossos casos de teste.

=> Confira o guia de treinamento Perfect TestNG aqui.

Leitura recomendada

^