43 perguntas da entrevista do TestNg: a maioria dos iniciantes não sabe

Neste tutorial, vamos discutir os conjuntos exaustivos de Perguntas e respostas críticas da entrevista TestNg e distribuído dependendo do nível de dificuldade, onde você pode se equipar melhor rapidamente no TestNg

Esses conjuntos de perguntas da entrevista de teste são distribuídos nos seguintes módulos ou conjunto:

TestNg Interview Questions - Advance

Perguntas da entrevista TestNg - Nível intermediário

Perguntas da entrevista TestNg - Básico

Perguntas e respostas da entrevista de teste || Conjunto 1

Como você exclui um grupo do ciclo de execução de teste?

Você pode usar a tag de exclusão para excluir um grupo de casos de teste da execução da maneira abaixo no arquivo xml de teste 

    

        

        

    

Quais são os tipos de relatórios gerados no TestNG por padrão?

O TestNG gera 4 tipos de relatórios após a execução, que são:

  • Relatório HTML TestNG
  • Relatório de e-mail TestNG
  • XML do relatório TestNG
  • Relatório XML com falha do TestNg

Mencionou a diferença entre o conjunto de testes TestNG e o teste TestNG?

O conjunto de testes TestNG é a coleção de classes e métodos de teste que podem ser executados simultaneamente ou paralelamente a partir do arquivo XML TestNG. 

Por outro lado, o método de teste TestNG é um único arquivo de caso de teste ou método de teste.

Qual é o uso do atributo threadPoolSize com a anotação @Test 

Por meio do atributo threadPoolSize, podemos definir um pool de threads com o tamanho específico mencionado pelo número do método de teste a ser executado por meio de várias threads disponíveis.

O atributo está sendo ignorado se invocationCount não está sendo mencionado.

@Test(threadPoolSize = 3)
public void testCaseOne(){
System.out.println("testCaseOne em processo");
}

No método de teste acima, testCaseOne será chamado a partir de três threads diferentes.

O que os atributos alwaysRun fazem?

Este atributo de anotação alwaysRun é usado sempre que você deseja executar o método de teste, independentemente dos parâmetros dependentes dos quais o método de teste depende, falha. Se você definir como verdadeiro, será necessário definir se o atributo é verdadeiro.

Quais são os diferentes ouvintes disponíveis?

  • ITestListener
  • Repórter 
  • ISSuiteListener
  • IAnnotationTransformador 
  • IAnotaçãoTransformador2
  • IHookable 
  • IInvokedMethodListener 
  • IMethodInterceptor 

Qual é o valor padrão para a Prioridade TestNG?

A prioridade TestNG tem o valor padrão zero.

Como executar novamente TestNg Failed Tests usando o mecanismo de Auto Retry?

TestNg fornece uma interface chamada de IRetryAnalyzer ouvinte que você pode implementar a interface reexecuta automaticamente seus scripts de teste com falha, mencionando a classe no arquivo testNg.XML. Aqui está o código abaixo para implementar o mesmo:

TestNg Tentar novamente 1024x747 1
Perguntas e respostas da entrevista de teste - Script de teste de repetição TestNg

Na área acima você pode configurar o número de novas tentativas, contagens máximas e também você pode mencionar em quais exceções você deseja executar novamente os scripts de teste.

public class Retry implementa IRetryAnalyzer { int retryCounter = 0; // O número máximo de execução com falha int autoRetryLimit = 2; @Override public boolean retry(ITestResult iTestResult) { if (retryCounter < autoRetryLimit) { retryCounter++; retorne verdadeiro; } retorna falso; } }

Abordagem dois: como executar novamente TestNg falhou testes usando o mecanismo de repetição automática

Na abordagem abaixo, você pode construir 2 classes, ou seja, uma é Tentar aula novamente onde você pode manter a lógica de controlar o número de iterações em caso de falhas de teste que irá implementar a interface Testng IRetryAnalyzer.

Outra classe é basicamente a que implementará o outro ouvinte de interface IAnnotationTransformer e implementará o método transformar que interage internamente com a aula anterior (ou seja, Tentar aula novamente)

public class Retry implementa IRetryAnalyzer { int retryCounter = 0; // O número máximo de execução com falha int autoRetryLimit = 2; @Override public boolean retry(ITestResult iTestResult) { if (retryCounter < autoRetryLimit) { retryCounter++; retorne verdadeiro; } retorna falso; } }

e finalmente adicione o Classe CognitiveRetry no listener do arquivo testng.xml.

<listeners>
    <listener class-name= "com.lambdageeks.cognitiveRetryUtils.CognitiveRetry"/>
</listeners>

Como obter a implementação do itestlistener do TestNG?

ITestListener é uma interface em TestNg que possui vários métodos (não implementados, pois é uma interface) que podem ser implementados por uma classe. Cada método representa funcionalidades ou cenários específicos, portanto, dependendo de sua necessidade, você pode implementar esses métodos.

Por exemplo onTestFailure é um método que você pode implementar onde deseja realizar qualquer operação enquanto qualquer método de teste falha, digamos que você deseja capturar a captura de tela no caso de falha de qualquer método de teste, então você pode escrever o método takescreenshot dentro do onTestFailure , e como o ITestListener é uma interface, o testNg continuará ouvindo os eventos (falhas de teste) e sempre que houver falhas de teste sua captura de tela será capturada.

Esta é a implementação da captura de tela sempre que o script de teste encontra uma falha:

importar org.apache.commons.io.FileUtils; importar org.openqa.selenium.OutputType; importar org.openqa.selenium.TakesScreenshot; importar org.openqa.selenium.WebDriver; importar org.testng.ITestContext; importar org.testng.ITestListener; importar org.testng.ITestResult; importar java.io.File; importar java.io.IOException; importar java.util.logging.Logger; classe pública CustomListerners implementa ITestListener { WebDriver driver=null; String filePath = "D:\\\\LambdaGeeks\\\\SCREENSHOTS"; @Override public void onTestFailure(resultado ITestResult) { String testMethodName=String.valueOf(result.getName()).trim(); ITestContext testContext = result.getTestContext(); Driver WebDriver = (WebDriver)testContext.getAttribute("driver"); captureTheScreenShot(testMethodName, driver); } public void captureTheScreenShot (String methodName, driver WebDriver) { Arquivo scrFile = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE); /* Cada captura de tela será salva junto com o nome do teste para ter melhor correlação */ try { FileUtils.copyFile(scrFile, new File(filePath+methodName+".jpg")); } catch (IOException e) { e.printStackTrace(); } } public void onFinish(contexto ITestContext) {} public void onTestStart(resultado ITestResult) { } public void onTestSuccess(resultado ITestResult) { } public void onTestSkipped(resultado ITestResult) { } public void onTestFailedButWithinSuccessPercentage(resultado ITestResult) { } public void onStart (contexto ITestContext) { } }

E também você precisa adicionar esta classe na tag do listener no arquivo testng.xml como fizemos na pergunta anterior.

Como implementar o testng iAnnotationtransformer?

TestNg fornece uma interface chamada IAnnotationTransformer que fornece um método chamado “transform” que você pode implementar e seria acionado em tempo de execução por TestNG, esta implementação é usada para modificar o comportamento de anotação de teste da classe de teste e métodos de teste

No segmento abaixo, veríamos como poderíamos fazer isso

public class TestClassAnnotations { @Test(alwaysRun = true,dependsOnMethods = "testMethodB") public void testMethodA() { System.out.println("--- Personalizando o comportamento do tempo de execução com ITestAnnotation ---"); } @Test public void testMethodB() { System.out.println("--- Segundo Métodos de Teste ---"); Assert.fail(); } }

Por padrão, se executarmos o código acima, apenas um método será executado, que é testMethodA, e outro método testMethodB falhará porque estamos falhando intencionalmente usando o método Assert.fail ().

Mas se mudarmos o Alwaysrun = true anotação para falsa usando o IAnnotationTransformador então este método não será executado, abaixo está o trecho de código sobre como implementar o IAnnotationTransformador e use-o no testing.xml para alterar o comportamento da anotação TestNG

A implementação de CustomAnnotationTransformers vai aqui:

public class CustomAnnotationTransformers implementa IAnnotationTransformer { public boolean isTestRunning(ITestAnnotation iTestAnnotation) { if (iTestAnnotation.getAlwaysRun()) { return true; } retorna falso; } public void transform(ITestAnnotation annotations, Class testClasses, Construtor testConstructors, Método testMethods) { if (isTestRunning(annotations)) { annotations.setEnabled(false); } } }

Aqui está o ouvinte que precisamos adicionar no arquivo testing.xml

<listeners>
    <listener class-name= "com.lambdageeks.CustomAnnotationTransformers"/>
</listeners>

Como implementar testng iinvokedmethodlistener?

Se você deseja implementar um recurso onde um determinado método será executado antes e depois de cada método de teste de TestNg, então esse recurso pode ser implementado pelo IInvokedMethodListener ouvinte.

 

Aqui está o snippet de código para implementar os recursos:

pacote com.lambdageeks; import org.testng.IInvokedMethod; import org.testng.IInvokedMethodListener; importar org.testng.ITestResult; public class CustomAnnotationTransformers implementa IInvokedMethodListener { public void beforeInvocation(método IInvokedMethod, ITestResult testResult) { System.out.println(" ::: Before Method from IInvokedMethodListener é acionado para o método de teste chamado como : " + method.getTestMethod().getMethodName( ) + " ::: "); } public void afterInvocation(método IInvokedMethod, ITestResult testResult) { System.out.println(" :::: Após o método de IInvokedMethodListener é acionado para o método de teste chamado como : " + method.getTestMethod().getMethodName() + " : :: "); } }

Aqui está a classe de teste para testar o recurso:

public class TestClassAnnotations { @Test(alwaysRun = true) public void testMethoddummy() { System.out.println("--- Este é um método de teste, testando o recurso de IInvokedMethodListener Testng Listener ---"); } }

Você deve mencionar o TestNG iinvokedmethodlistener na tag do ouvinte no testng.xml como sempre

<listeners>
    <listener class-name="com.lambdageeks.CustomAnnotationTransformers"/>
</listeners>

A saída da execução ficaria assim:

::: Before Method from IInvokedMethodListener is Triggered for Test Method nomeado como: testMethoddummy :::

- Este é um método de teste, testando o recurso do IInvokedMethodListener Testng Listener -

 :::: Após o método de IInvokedMethodListener ser acionado para o método de teste denominado como: testMethoddummy :::

Como implementar provedores de dados no TestNG?

Podemos implementar o DataProvider usando TestNg na abordagem abaixo:

public class DataProviderDemo { @DataProvider(name = "dpName") public Object[][] dataProvidersMethodName() { return new Object[][]{{"Lambda"}, {"Geeks"}}; } @Test(dataProvider = "dpName") public void dataproviderDummyTestMethod(String dataValues) { System.out.println("Os parâmetros de dados com exemplos de provedores de dados : : " + dataValues); } }

Se não definirmos a prioridade do método de teste, em que ordem os testes são executados no TestNG?

Os testes são executados na ordem alfabética do TestmethodName.

 

Como no snippet de código abaixo:

public class Teste de Sequência { @Test() public void geeks() { System.out.println("Teste de Sequência , Método executado :geeks "); } @Test() public void lambda() { System.out.println("Teste de Sequência, Método executado: lambda "); } @Test() public void abc() { System.out.println("Teste de Sequência, Método executado :abc"); } }

A saída ficaria assim:

Teste de sequência, método executado: abc

Teste de sequência, método executado: geeks

Teste de sequência, método executado: lambda

 

Como executar seus scripts de teste em paralelo?

Você pode executar seus scripts de teste usando o arquivo TestNg XML, mencionando o paralelo = ”métodos” thread-count = ”2 ″, aqui 2 casos paralelos serão executados, se você quiser executar mais threads em paralelo.

<suite name="DummyTest" parallel="methods" thread-count="2" >

<listeners>
<listener class-name="org.uncommons.reportng.HTMLReporter" />
<listener class-name="org.uncommons.reportng.JUnitXMLReporter" />
</listeners>
</suite>  

Como integrar TestNg com GRADLE build Tool?

Você pode executar o Testng Suite no gradle de diferentes maneiras:

Como executar grupos TestNg usando Gradle: Você pode criar uma tarefa no arquivo build.gradle pode mencionar o useTestNG () e mencione os detalhes abaixo durante a execução dos grupos de teste.

TestNg GradleName
Perguntas e respostas da entrevista TestNg-TestNg com Gradle

Como executar o ouvinte Testng Default com Gradle para gerar relatório usando a biblioteca TestNg

TestNg Ouvintes padrão
TestNg Interview Questions and Answers - Testng with Gradle Default Listeners

Se você deseja usar o ouvinte personalizado, pode mencioná-lo na seguinte abordagem:

Teste Gradle Custom listener 1024x497 1
Perguntas e respostas da entrevista TestNg - Ouvintes personalizados do TestNG com Gradle

Como executar o arquivo xml Testng Runner usando o prompt de comando?

Você pode usar o local de download do TestNg e mencionar org.testng.TestNg.testNgRunner.xml para executar o arquivo xml do executor no prompt de comando.

java -cp "/opt/testng-7.1.jar:bin" org.testng.TestNG testngRunner.xml

Como integrar o TestNg XML ao Maven?

Você pode integrar TestNg com Maven com o uso de um plugin chamado plugin-maven-surefire onde você pode configurar para executar o arquivo testNgrunner.xml usando as configurações:

Integração TestNG Maven 1024x667 1
Perguntas e respostas da entrevista TestNg-Integração TestNg-Maven-Surefire

Como você pode especificar o parâmetro TestNg Test usando TestNg e Maven?

Você pode especificar o parâmetro Test usando o plug-in Maven SureFire com o arquivo TestNg.XML da maneira abaixo

TestNg Maven TestParameter 1024x543 1
Parâmetro de perguntas e respostas da entrevista TestNg

Perguntas e respostas da entrevista de teste || Conjunto 2

O que significa invocationCount no TestNG?

invocationCount é um atributo de anotação de teste pelo qual você pode definir o número de iterações em que o método de teste será executado em uma única execução. 

 O teste acima será executado duas vezes, pois invocationCount é mencionado como 2.

@Test(invocationCount = 2) public void testOfInvCount() { System.out.println("Teste de contagem de invocação em andamento"); }

O que são ouvintes no TestNG?

em TestNg, os ouvintes são basicamente uma interface em Java que você precisa implementar em sua classe. A classe implementada continuará ouvindo certos eventos e executará o bloco específico de código associado a esse evento. Aqui, quando você implementa a interface, você implementa os métodos não implementados e esses blocos de código ou os métodos serão executados como e quando o evento específico é acionado. 

Com a ajuda dos ouvintes TestNG, podemos realizar várias ações em tempo de execução, ouvindo um evento diferente disparado pela execução do script de teste e seu status, ou podemos fazer relatórios. Além disso, podemos alterar a implementação da anotação TestNg.

Mencionar as diferenças entre as anotações @Factory e @Dataprovider no TestNg?

@Dataprovider: Quando você deseja executar o mesmo teste, mas com diferentes conjuntos de dados diferentes em cada execução, você pode usar a anotação dataprovider, e com isso você pode obter a abordagem de teste orientado por dados. Aqui, a execução do método de teste acontece usando a mesma instância de classe à qual o método de teste pertence.

@Factory: será executado todos os métodos de teste presentes dentro de uma classe de teste usando instâncias separadas e múltiplas da classe.

Como usar a classe TestNG Reporter para a geração de logs?

Você pode registrar os detalhes e dados usando a classe Reporter, e esses registros serão capturados pelo relatório gerado pelo TestNG

Reporter.log (”Mensagem de registro“);

Como fazer o tratamento de exceções no TestNG?

Você pode mencionar o tipo de exceção esperada em um atributo chamado expectedExceptions com a anotação @test; neste caso, o TestNg marcará o teste como aprovado.

@Test (expectedExceptions = numberFormatException.class)

Como obter injeção de dependência via TestNg XML?

TestNG nos permite injetar dependências entre diferentes grupos de testes por meio do arquivo XML TestNG. Por meio do qual podemos ter a dependência de um grupo para outro.

Quais são as várias abordagens de afirmação para TestNG?

Podemos usar dois tipos de asserções com TestNg. 

Declarações suaves

Afirmações definitivas 

Mencione algumas das afirmações comumente usadas com TestNG 

Alguns dos métodos de afirmação amplamente usados ​​no TestNG:

  • assertEquals (booleano real, booleano esperado)
  • assertEqual (String real, String esperada)
  • assertEqual (Resultado real da string, Resultado esperado da string, mensagem da string)
  • assertTrue (condição)
  • assertFalse (condição)
  • assertFalse (condição, mensagem)
  • assertTrue (condição, mensagem)

O que você entende por afirmações no TestNG?

Uma afirmação é executada para validar os resultados reais do teste em relação aos resultados esperados do teste. Em TestNg, podemos usar afirmação direta ou afirmação suave. 

Diferença entre Hard assert e soft assert em TestNg

Ao trabalhar com a assertiva de disco rígido, se obtivermos alguma falha na condição de asserção, as etapas de teste subsequentes não serão executadas e serão abortadas e, eventualmente, o teste será marcado como um caso de teste com falha. 

Por outro lado, o Soft Assert leva em consideração a validação de todos os pontos de afirmação, mesmo que haja alguma falha em qualquer uma das afirmações. Isso significa que a execução do teste não é abortada mesmo se uma asserção falhar.

Como escrever uma afirmação suave em TestNg 

O trecho de código abaixo fornece a abordagem de escrever a asserção suave no TestNG

@Test public void assertion() { SoftAssert softAssertion = new SoftAssert(); //Asserção 1 softAssertion.assertEquals("exp", "act"); //Asserção 2 softAssertion.assertEquals(123, 123); //Asserção 3 softAssertion.assertEquals("valor real", "valor esperado"); // No final considerando todos os valores de asserção softAssertion.assertAll(); }

Como usar a expressão regular em grupos TestNG?

Uma expressão regular pode ser usada em TestNG para executar os grupos que têm um padrão semelhante em sua nomenclatura. 

Por exemplo, se você deseja executar todos os grupos começando com “testX” de acordo com o nome em questão, então você pode usar a expressão regular como testX. * No arquivo XML TestNG.

Perguntas e respostas da entrevista de teste || Conjunto 3

O que é TestNG?

TestNg basicamente representa “Testando a próxima geração”É uma estrutura de teste de unidade que controla o fluxo e a ordem dos scripts de automação e automação de teste, fornecendo várias anotações com suas funcionalidades.

Quais são as vantagens do TestNg?

  •             Através das várias anotações do Testng, você pode controlar o fluxo e a ordem de automação e execução de Testes de uma maneira melhor.
  •             Classes de teste ou métodos de script de teste A execução paralela pode ser alcançada com TestNg.
  •            O TestNg pode ser facilmente integrado a diferentes ferramentas de compilação, como Maven, Gradle. Além disso, pode ser integrado com ferramentas CICD, como Jenkins.
  •            O TestNG fornece detalhes do recurso de relatórios HTML e é facilmente integrado a outras plataformas de relatórios de teste, como Allure, Extent Report com recursos de TestNG Listeners.
  •           Todos os testes podem ser acionados pelo arquivo testng.xml onde você pode mencionar o nome da classe de teste/teste/pacote de teste a ser executado.
  •           O teste orientado a dados pode ser feito com a anotação TestNg DataProvider. Além disso, Testes de parametrização também podem ser feitos através do Testng.xml, como ao realizar testes entre navegadores, você pode parametrizar os diferentes navegadores para diferentes testes. Esse recurso ajuda a construir o Data Driven Framework com TestNG.
  •          TestNg Fornece uma maneira de incluir/excluir um conjunto de um teste de tesngNg.xml com o atributo include e exclude.
  •          Com TestNg, você pode agrupar seus testes e injeção de dependência entre os testes.
  •          TestNg fornece muitos ouvintes com aqueles que você pode conseguir muitas coisas, como fazer relatórios personalizados (IReporter), integração com diferentes ferramentas (ITestListener), alterar o comportamento da anotação de teste TestNG em tempo de execução com IAnnotationTransformer e muito mais.
  •         Você pode pular o teste específico, priorizar seu pedido de teste, criar um teste com limite de tempo com anotações do TestNg Test.
  •         Você pode usar o Hard Assertion, bem como o Soft Assertion com TestNg para escrever a declaração Assert.
  •         TestNg gera TestNG-failed.xml após cada execução de teste, para que você possa gerar o mesmo TestNG-failed.xml para executar novamente seus scripts de teste com falha.
  •        TestNg fornece várias anotações de teste, como @BeforeMethod, @AfterMethod, @BeforeTest, @AfterTest.@AntesSuite,@PósSuite.
  •        Você pode executar o teste de exceção esperado com TestNg.
  •        Você pode executar novamente o teste com falha com IretryAnalyzer de Testng 

Como você acionar e executar o script de teste TestNg?

Você pode executar o script TestNg Test de várias maneiras: 

  •       Clique com o botão direito do mouse em Test Class e "executar como" e selecione a opção "TestNg Test".
  •       Crie testng.xml e direto no arquivo e execute o arquivo xml.
  •       Se você integrar testNg.xml com a ferramenta de compilação, como Maven/Gradle, também poderá executar a partir do maven ou do Gradle.
  •       Se a ferramenta de compilação, como Maven/Gradle, estiver integrada ao CICD, você poderá executar a partir do CICD, ou seja, do Jenkins.

Indique as anotações de teste que estão disponíveis?

As anotações de teste de teste mais usadas são:

  • @AntesSuite
  • @AfterSuite
  • @AntesTeste
  • @DepoisTeste
  • @Antes da aula
  • @Depois da aula
  • @BeforeMethod
  • @AfterMethod
  • @BeforeGroups
  • @AfterGroups
  • @Teste

Mencionar a sequência de execução das anotações TestNg?

Do ponto de vista da execução do teste, aqui está a sequência abaixo para todas as anotações TestNg disponíveis:

Anotações de pré-condição:

  • @AntesSuite
  • @AntesTeste
  • @Antes da aula
  • @BeforeMethod
  • Anotações de teste:
  • @Teste
  • Anotações pós-condição: 
  • @AfterSuite
  • @DepoisTeste
  • @Depois da aula
  • @AfterMethod

Como desabilitar a execução de teste para um script de teste?

Você pode usar o atributo ativado é igual a falso no atributo de anotação @Test conforme mencionado abaixo:

@Test(enabled = false) public void logout(){ System.out.println("Exemplo de teste"); }

Como você pode especificar ouvintes em TestNG xml?

Você pode usar o arquivo xml Tesng para mencionar os ouvintes a serem usados ​​como parte das execuções do script de teste, na abordagem abaixo:

        

        

...

O que é o teste de tempo limite no TestNg?

Nesse caso, o “teste de tempo limite” significa que, se o script de teste demorar mais do que o período de tempo especificado para ser executado, o teste abortará o teste e será marcado como um teste reprovado.

@Test(timeOut = 6000) // desta vez em multissegundos public void testShouldPass() throws InterruptedException { Thread.sleep(2000); }

Como realizar o teste de exceção esperada com TestNG?

Se um método Test lançar uma exceção, que é a mesma especificada como parte do atributo expectationExceptions da anotação de teste, então TestNg marcará o teste como aprovado.

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

 O método de teste acima será passado ao lançar a exceção esperada pelo TestNG.

Qual é a diferença entre a anotação @BeforeTest e @BeforeMethod?

@BeforeTest é executado uma vez antes de cada um dos testes etiqueta mencionado no arquivo testng.xml 

@BeforeMethod é executado antes de cada método de script de teste.

Qual é a vantagem de usar o arquivo testng.xml?

Com o arquivo testng.xml, você pode controlar o fluxo de execução com um único conjunto de testes ou vários conjuntos de testes em um único arquivo xml testng. Alguns dos recursos importantes são:

  • O arquivo testng.xml nos permite excluir e incluir métodos de teste e execução do grupo de teste.
  • Você pode passar dados/parâmetros de teste por meio de testng.xml.
  • Você pode adicionar dependência entre métodos de teste e também um grupo de métodos de teste
  • Você pode priorizar os casos de teste.
  • A execução de teste paralela de casos de teste é alcançada.
  • Você pode implementar diferentes ouvintes testng e usá-los mencionando-os no testng.xml.
  • Se você executar seu conjunto com testng.xml, você só falhará no teste para a próxima iteração usando TestNG-failed.xml é gerado após cada execução.
  • Você pode executar grupos específicos de testes usando tag de TestNG xml.

Quantos tipos de dependências você pode alcançar usando TestNG?

Existem dois tipos de dependências que podemos alcançar com TestNG: 

A. DependsOnMethods: 

Ao usar este atributo dependsOnMethods, você está definindo qual método de teste será dependente de outros métodos de teste. Portanto, se o método dependente falhar ou não for executado, o método de teste dependente também não será executado.

@Test public void loginUserProfile() { System.out.println("Login de usuário "); } @Test(dependsOnMethods = "loginUserProfile") public void logOutPage_user() { System.out.println("Página de logout do usuário"); }

 Aqui está o método de teste logOutPage_user que será executado após a execução bem-sucedida do teste loginUserProfile.

B. DependeOnGroups: 

Neste tipo de dependência de teste, permite-nos colocar a injeção de dependência para os métodos de teste com um grupo de métodos de teste.

O fluxo de execução acontece de tal forma, isto é, o testGroup primeiro é acionado e executado e, em seguida, o método de teste dependente é acionado e, uma vez após a conclusão bem-sucedida do teste de grupo, o método de teste dependente será executado.

@Test(groups="AtestGroupName") public void testcaseOne() { System.out.println("testcaseOne in process"); } @Test(groups="AtestGroupName") public void testcaseTwo() { System.out.println("testcaseTwo in process"); } @Test(dependsOnGroups="AtestGroupName") public void testcaseThree() { System.out.println("testcaseThree in process"); }

Conclusão: Com isso, concluímos a lista de todas as críticas e importantes Perguntas e respostas da entrevista TestNg , para obter melhor controle sobre o TestNg, você pode passar pelo documentação exaustiva sobre TestNg.

Para saber mais sobre o tutorial completo do Selenium que você pode visitar aqui.

Deixe um comentário