50 topo TestNG Perguntas e respostas da entrevista (2026)

Preparando-se para um TestNG Entrevista? É hora de pensar em perguntas que destaquem seus pontos fortes. Uma sólida TestNG A base da entrevista revela profundidade, confiança e prontidão, qualidades valorizadas pelas equipes de recrutamento.

As oportunidades neste domínio abrangem o crescimento da automação, a evolução de frameworks e aplicações práticas de testes que exigem experiência técnica e profissional. Trabalhar na área demanda conhecimento especializado, capacidade analítica e um conjunto de habilidades flexível que ajuda profissionais iniciantes, de nível intermediário e sênior a solucionar as principais dúvidas e perguntas em níveis técnico, básico e avançado. Leia mais ...

👉 Download gratuito de PDF: TestNG Perguntas e respostas da entrevista

Soutien TestNG Perguntas e Respostas da Entrevista

1) O que é TestNG E por que é utilizado em testes de automação?

TestNG (Test Next Generation) é uma estrutura de testes inspirada em JUnit e NUnit, mas aprimorado com recursos avançados como agrupamento, sequenciamento, parametrização e gerenciamento de dependências. É usado principalmente em testes automatizados para otimizar a execução de testes, melhorar a organização dos testes e gerar relatórios detalhados em HTML e XML.

Principais benefícios de TestNG incluem:

• suportes execução de teste em paralelo, reduzindo o tempo total de execução.
• Fornece anotações que controlam o fluxo de testes de forma eficaz.
• Promoções teste baseado em dados através de @DataProvider anotação.
• gera relatórios personalizáveis Para melhor depuração.

Por exemplo, nos TestNG Permite executar grupos de testes de fumaça, regressão e integração de forma independente, sem modificar o código de teste, oferecendo flexibilidade e escalabilidade em grandes conjuntos de automação.

---

2) Explique o TestNG ciclo de vida com anotações e sua ordem de execução.

O processo de TestNG O ciclo de vida define como os testes são inicializados, executados e finalizados. Ele é controlado por meio de anotações que fornecem estrutura e clareza ao fluxo de testes.

Anotação	Descrição	Ordem de Execução
@BeforeSuite	Executado antes de todos os testes do conjunto.	1
@BeforeTest	Executa antes <test> tag em XML	2
@BeforeClass	Executa antes do primeiro método da classe atual.	3
@BeforeMethod	Executa antes de cada método de teste	4
@Test	Contém lógica de teste real	5
@AfterMethod	Executa após cada método de teste.	6
@AfterClass	Executa após todos os métodos da classe.	7
@AfterTest	Corre depois <test> tag em XML	8
@AfterSuite	Executa após todos os testes na suíte	9

Essa ordem estruturada garante a configuração e a desmontagem previsíveis dos testes, o que é crucial para manter a independência dos mesmos.

---

3) Como é TestNG diferente JUnit?

Embora ambas as estruturas sejam usadas para testes unitários, TestNG Oferece recursos mais robustos de configuração e execução paralela.

Característica	JUnit	TestNG
Execução Paralela	Suporte limitado	Apoio total
Anotações	Menos (@Before, @After)	Mais rico (@BeforeSuite, @DataProvider)
Gerenciamento de Dependências	Não disponível	Disponível usando dependsOnMethods
Agrupamento	Não suportado	Suportado por meio de groups
Parametrização	Por meio de corredores externos	Integrado via XML ou @DataProvider

Em suma, TestNG é preferido para testes de automação em nível empresarial e integração com ferramentas como Selenium, enquanto que JUnit É ideal para testes unitários mais simples.

---

4) O que são TestNG Anotações: e qual a sua utilidade?

Anotações em TestNG definir a estrutura e o comportamento dos métodos de testeEles eliminam a necessidade de configurações XML complexas, fornecendo controle de teste declarativo diretamente no código.

As anotações mais comuns incluem:

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

Exemplo:

@BeforeMethod
public void setup() {
    System.out.println("Initializing browser...");
}

@Test
public void verifyLogin() {
    System.out.println("Executing login test...");
}

Isso ajuda os desenvolvedores a organizar a execução dos testes de forma lógica, garantindo que a configuração, a execução dos testes e a finalização ocorram em uma ordem definida.

---

5) Explique o conceito de agrupamento em TestNG.

Agrupamento em TestNG Permite a categorização lógica de testes em conjuntos menores e gerenciáveis, como "Fumaça", "Regressão" ou "Sanidade".

Exemplo:

@Test(groups = {"Smoke"})
public void loginTest() { ... }
@Test(groups = {"Regression"})
public void paymentTest() { ... }

Você pode configurar seu conjunto de ferramentas XML para executar grupos específicos:

<groups>
  <run>
    <include name="Smoke"/>
  </run>
</groups>

Benefícios:

• Facilita a execução seletiva de casos de teste.
• Aumenta a flexibilidade nos pipelines de CI/CD.
• Economiza tempo de execução durante compilações incrementais.

---

6) Como a parametrização pode ser alcançada em TestNG?

A parametrização permite testes orientados por dados, possibilitando a execução de testes com múltiplos conjuntos de dados de entrada. TestNG Suporta dois métodos principais:

1. Utilizar painéis de piso ResinDek em sua unidade de self-storage em vez de concreto oferece diversos benefícios: @Parameters Anotação com XML:

<parameter name="browser" value="chrome"/>
@Test
@Parameters("browser")
public void launchBrowser(String browser) { ... }

2. Utilizar painéis de piso ResinDek em sua unidade de self-storage em vez de concreto oferece diversos benefícios: @DataProvider:

@DataProvider(name="loginData")
public Object[][] getData() {
  return new Object[][] {{"user1","pass1"}, {"user2","pass2"}};
}

@Test(dataProvider="loginData")
public void loginTest(String user, String pass) { ... }

Essa flexibilidade facilita a manutenção e a execução de grandes conjuntos de testes em diferentes ambientes ou configurações.

---

7) O que são dependências em TestNG E como são geridos?

Dependências em TestNG controlar a ordem de execução dos testes com base nos resultados de outros testes usando o dependsOnMethods or dependsOnGroups atributos.

Exemplo:

@Test
public void loginTest() { ... }

@Test(dependsOnMethods = {"loginTest"})
public void verifyDashboard() { ... }

Se o método dependente falhar, o teste subsequente será ignorado automaticamente.

Esse mecanismo impede a execução de testes inválidos e ajuda na manutenção. integridade do teste lógicoÉ especialmente útil para fluxos funcionais de várias etapas, como login → executar ação → verificar resultado.

---

8) Quais são as diferentes maneiras de executar TestNG testes?

TestNG Os testes podem ser executados de diversas maneiras flexíveis, dependendo da configuração de teste:

1. Do IDE (Eclipse/IntelliJ): Clique com o botão direito do mouse na aula ou XML file → Run as → TestNG Test.
2. A partir da linha de comando: java -cp "path\testng.jar;bin" org.testng.TestNG testng.xml
3. Utilizando as Ferramentas de Compilação:
   • Especialista: configurar surefire-plugin in pom.xml.
   • Gradle: Uso testng Configuração de dependências e tarefas.
4. Por meio de pipelines CI/CD: Integrado com Jenkins ou GitHub Actions para execução automatizada.

Essa variedade garante a compatibilidade entre ambientes de desenvolvimento, teste e produção.

---

9) O que são TestNG ouvintes e por que eles são importantes?

Ouvintes em TestNG Fornece mecanismos para personalizar o comportamento dos testes, monitorando eventos de execução como início, sucesso, falha ou omissão.

Ouvintes comuns:

• ITestListener: Monitora eventos no nível do método de teste.
• ISuiteListenerObserva eventos em nível de suíte.
• IReporterGera relatórios personalizados.

Exemplo:

public class CustomListener implements ITestListener {
  public void onTestFailure(ITestResult result) {
    System.out.println("Test Failed: " + result.getName());
  }
}

Os ouvintes são frequentemente usados ​​para gravar Capturas de tela sobre falhas, gerando registros personalizados, ou integração com ferramentas de relatório como Allure ou ExtentReports.

---

10) Quais são as vantagens e desvantagens de usar TestNG?

Aspecto	Vantagens	Desvantagens
Flexibilidade	Suporta agrupamento, dependência e execução paralela.	Configuração XML complexa para grandes suítes
Relatórios	Fornece relatórios detalhados em HTML e XML.	Personalização limitada sem ouvintes
Integração	Funciona perfeitamente com Selenium e ferramentas de CI/CD	Curva de aprendizado um pouco maior
Parametrização	Suporte integrado para testes orientados por dados	Requer manutenção para grandes conjuntos de dados.

No geral, TestNG É uma estrutura robusta e flexível, adequada para ambientes modernos de teste de automação, apesar de sua pequena sobrecarga de configuração.

---

11) Como você pode priorizar casos de teste em TestNG?

TestNG fornece o priority atributo no @Test Anotação para definir a ordem em que os métodos de teste devem ser executados. Os testes com valores de prioridade mais baixos são executados primeiro.

Exemplo:

@Test(priority = 1)
public void loginTest() { ... }

@Test(priority = 2)
public void dashboardTest() { ... }

Se nenhuma prioridade for especificada, o valor padrão será 0, e os métodos são executados em ordem alfabética.

Melhor Prática: Use valores de prioridade com moderação. O uso excessivo pode tornar a ordem dos testes rígida. Para fluxos complexos, o gerenciamento de dependências (dependsOnMethods) é mais fácil de manter do que a priorização estrita.

---

12) Explique o conceito e a utilização da execução paralela em TestNG.

Execução paralela em TestNG Permite que vários testes, classes ou métodos sejam executados simultaneamente, reduzindo significativamente o tempo total de execução.

Você pode ativar esse recurso em testng.xml arquivo:

<suite name="ParallelSuite" parallel="tests" thread-count="3">
  <test name="Test1">...</test>
  <test name="Test2">...</test>
</suite>

Modos paralelos suportados:

• tests
• classes
• methods
• instances

Vantagens:

• Ciclo de feedback mais rápido.
• Utilização eficiente de processadores multi-core.
• Escalabilidade para grandes conjuntos de automação.

No entanto, certifique-se de segurança da rosca Ao usar recursos compartilhados, como WebDriver ou conexões de banco de dados.

---

13) O que são provedores de dados em TestNGEm que diferem dos parâmetros?

@DataProvider permite teste baseado em dados fornecendo aos métodos de teste múltiplos conjuntos de dados.

Exemplo:

@DataProvider(name="credentials")
public Object[][] data() {
    return new Object[][] {{"user1", "pass1"}, {"user2", "pass2"}};
}

@Test(dataProvider="credentials")
public void login(String username, String password) { ... }

Diferença entre @Parameters e @DataProvider:

Característica	@Parameters	@DataProvider
Fonte de dados	Arquivo XML	Java método
Tipo de dados	Conjunto de dados único	Vários conjuntos de dados
Flexibilidade	Less	Alto
Caso de uso	Variáveis ​​ambientais	Testes repetidos baseados em dados

Conseqüentemente, @DataProvider É preferível ao executar um único teste com vários conjuntos de dados, como verificar o login com várias credenciais.

---

14) Como desativar ou pular um teste em TestNG?

Você pode desativar um teste em TestNG usando o enabled atributo ou omitindo-o programaticamente.

1. Usando enabled = false:

@Test(enabled = false)
public void skipTest() {
    System.out.println("This test will not run.");
}

2. Ignorando durante a execução usando SkipException:

@Test
public void conditionalSkip() {
    throw new SkipException("Skipping this test due to condition.");
}

Desativar é útil para desativação temporária Testes instáveis ​​ou incompletos sem excluí-los. Ignorar testes é valioso para condições de tempo de execução, como ignorar testes para navegadores não suportados.

---

15) Qual é a função do arquivo testng.xml e quais são seus principais componentes?

O processo de testng.xml O arquivo é a espinha dorsal da configuração de TestNGDefine conjuntos de testes, grupos de testes, parâmetros e configuração de execução paralela.

Exemplo de estrutura:

<suite name="AutomationSuite">
  <parameter name="browser" value="chrome"/>
  <test name="RegressionTests">
    <classes>
      <class name="com.test.LoginTest"/>
      <class name="com.test.PaymentTest"/>
    </classes>
  </test>
</suite>

Componentes principais:

• <suite> – Define toda a suíte.
• <test> – Representa um bloco de teste.
• <classes> – Lista as classes de teste.
• <methods> – Filtra métodos de teste específicos.
• <parameter> – Fornece parâmetros globais ou de nível de teste.

O arquivo XML fornece controle centralizado sobre a execução sem alterar o código.

---

16) Como você pode gerar relatórios em TestNG?

TestNG gera automaticamente dois tipos de relatórios:

1. Relatório HTML (test-output/index.html) – Resume os testes aprovados, reprovados e ignorados.
2. Relatório XML – Utilizado para integração com ferramentas de CI/CD.

Para relatórios avançados, TestNG integra-se com:

• ExtentReports – Oferece painéis gráficos e registros detalhados.
• Relatórios da Allure – Fornece análises visuais com etapas de teste, capturas de tela e registros.

Exemplo de integração:

ExtentReports extent = new ExtentReports();
ExtentTest test = extent.createTest("Login Test");
test.pass("Test Passed Successfully");
extent.flush();

Esses relatórios são essenciais para acompanhar tendências e identificar áreas com deficiências na cobertura de testes.

---

17) O que são fábricas em TestNGe como eles funcionam?

Fábricas em TestNG são usados ​​para criar instâncias dinâmicas de classes de testeEles permitem a instanciação parametrizada de classes antes da execução dos testes.

Exemplo:

public class FactoryExample {
  private String browser;

  public FactoryExample(String browser) {
    this.browser = browser;
  }

  @Factory
  public static Object[] factoryMethod() {
    return new Object[] { new FactoryExample("Chrome"), new FactoryExample("Firefox") };
  }

  @Test
  public void testBrowser() {
    System.out.println("Running test on: " + browser);
  }
}

Vantagens:

• Habilita criação de objetos parametrizados.
• Ideal para teste cross-browser e execução em múltiplos ambientes.
  Os Factories complementam os DataProviders quando você precisa de diferentes configurações de objetos em vez de apenas variação de dados no nível do método.

---

18) Como você pode usar asserções em TestNG?

As asserções são usadas para validar os resultados esperados em comparação com os resultados reais dentro dos métodos de teste.

Tipos de Asserções:

1. Asserções rígidas (classe Assert):
   Interrompe imediatamente a execução do teste em caso de falha.

Assert.assertEquals(actual, expected);
Assert.assertTrue(condition);

2. Asserções suaves (classe SoftAssert):
   Continua a execução mesmo após falhas, relatando todos os problemas ao final.

SoftAssert soft = new SoftAssert();
    soft.assertEquals(actual, expected);
    soft.assertAll();

3. Quando usar:
• Use asserções rígidas para validação crítica como login bem-sucedido.
• Use asserções flexíveis para múltiplas verificações dentro de um único método de teste.

---

19) Explique a diferença entre @BeforeMethod e @BeforeClass em TestNG.

Aspecto	@BeforeMethod	@BeforeClass
Execução	Runs antes de cada método de teste	Runs uma vez antes qualquer método na classe
Objetivo	Por método de teste	Por turma de teste
Uso comum	Inicializando o navegador antes de cada teste.	Carregando a configuração ou a configuração do navegador uma vez

Exemplo:

@BeforeClass
public void setupClass() {
    System.out.println("Executed once per class");
}

@BeforeMethod
public void setupMethod() {
    System.out.println("Executed before each method");
}

Uso @BeforeMethod quando cada teste requer um ambiente limpo, e @BeforeClass para tarefas de inicialização complexas que podem ser reutilizadas.

---

20) Como é TestNG Suporte à injeção de dependência e quais são seus casos de uso?

TestNG suporta Injeção de dependência por meio da injeção integrada de objetos de contexto e configuração, como ITestContext, XmlTest, ou Method.

Exemplo:

@Test
public void testContextExample(ITestContext context) {
    System.out.println("Suite Name: " + context.getSuite().getName());
}

Casos de uso:

• Obtenção dinâmica de parâmetros de teste.
• Acesso a informações de configuração, como nomes de suítes ou configurações de execução paralela.
• Aumentando a flexibilidade dos testes sem a necessidade de definir dependências fixas.

A injeção de dependência permite que os desenvolvedores Escrever testes modulares e sensíveis ao contexto. que se adaptam dinamicamente às mudanças ambientais.

---

21) Qual é a diferença entre @Factory e @DataProvider em TestNG?

Ambos @Factory e @DataProvider ajudam com a parametrização, mas operam em Niveis diferentes na arquitetura de teste.

Característica	@Factory	@DataProvider
Objetivo	Nível de classe	Nível do método
Propósito	Cria múltiplas instâncias de uma classe com dados diferentes.	Fornece dados para um único método de teste
Execução	Executa a classe inteira para cada instância.	Executa um método várias vezes.
Caso de uso ideal	Testes entre navegadores ou ambientes	Testes funcionais orientados por dados

Exemplo:

• fábrica: Executa a classe inteira para cada tipo de navegador.
• Provedor de dados: Executa um método de teste com vários conjuntos de dados.

Uso @Factory quando a própria instanciação do objeto varia, e @DataProvider para variação de entrada funcional dentro da mesma instância de objeto.

---

22) Como você pode repetir automaticamente os casos de teste com falha em TestNG?

TestNG fornece um mecanismo para executar novamente os casos de teste com falha usando o IRetryAnalyzer interface.

Exemplo de implementação:

public class RetryAnalyzer implements IRetryAnalyzer {
  int count = 0;
  int maxTry = 2;

  public boolean retry(ITestResult result) {
    if (count < maxTry) {
      count++;
      return true;
    }
    return false;
  }
}

Uso:

@Test(retryAnalyzer = RetryAnalyzer.class)
public void testLogin() {
   Assert.fail("Intentional Failure");
}

Benefícios:

• Reduz a instabilidade em pipelines de CI.
• Lida com problemas transitórios de rede ou ambiente.

Melhor Prática: Combine a lógica de repetição com registros e capturas de tela adequados para depurar falhas intermitentes.

---

23) Qual é a utilidade do ITestContext em TestNG?

ITestContext fornece Informação contextual Informações sobre a execução do teste, incluindo nome do conjunto de testes, nome do teste, diretório de saída e parâmetros.

Exemplo:

@Test
public void contextExample(ITestContext context) {
    System.out.println("Suite: " + context.getSuite().getName());
}

Métodos principais:

• getSuite() – Recupera informações ao nível da suíte.
• getName() – Retorna o nome do teste.
• setAttribute() / getAttribute() – Compartilhar dados entre testes.

Habilita compartilhamento de dados entre métodos ou classes de teste e facilita a geração de relatórios e o registro de logs dinâmicos.

---

24) Como você pode criar dependência entre grupos de teste em TestNG?

Você pode definir dependências entre grupos usando o dependsOnGroups atributo no @Test anotação.

Exemplo:

@Test(groups = "Login")
public void login() { ... }

@Test(dependsOnGroups = "Login")
public void verifyProfile() { ... }

Isso garante que o verifyProfile O grupo é executado somente se todos os testes no Login Grupo aprovado com sucesso.

É particularmente útil em teste de integração, onde os módulos dependem da execução bem-sucedida de outros (por exemplo, fluxo de login → perfil → logout).

---

25) Como você pode ignorar certos métodos de teste em um TestNG Arquivo XML?

Você pode explicitamente excluir métodos dentro de uma classe no arquivo XML do conjunto de arquivos, usando <exclude> Tag.

Exemplo:

<class name="com.test.LoginTests">
  <methods>
    <exclude name="verifyLogout"/>
  </methods>
</class>

Isso permite que os testadores desativar métodos específicos temporariamente sem modificar o Java Código-fonte — útil em grandes suítes onde a inclusão ou exclusão dinâmica é necessária com base nos ciclos de lançamento ou nas prioridades do sprint.

---

26) Como pode TestNG ser integrado com Selenium WebDriver?

TestNG e Selenium Formam uma combinação poderosa para a automação da interface do usuário.

Uma configuração típica de integração envolve a organização de testes usando anotações, o gerenciamento de configuração/desmontagem e a execução de testes via XML ou ferramentas de CI.

Exemplo:

@BeforeMethod
public void setup() {
    driver = new ChromeDriver();
}

@Test
public void verifyTitle() {
    driver.get("https://example.com");
    Assert.assertEquals(driver.getTitle(), "Example Domain");
}

@AfterMethod
public void teardown() {
    driver.quit();
}

Benefícios de integração:

• Habilita teste paralelo de navegador.
• Simplifica agrupamento e relatório de testes.
• Funciona perfeitamente com Pipelines de CI / CD como o Jenkins ou o GitHub Actions.

---

27) Quais são algumas das melhores práticas ao usar TestNG Em grandes estruturas de automação?

Melhores Práticas:

1. Uso DescriptNomeação de ativos: Nomeie os testes com base no comportamento, não na implementação.
2. Agrupamento de alavancagem: Crie grupos de teste lógicos (Smoke, Regressão).
3. Evite codificar diretamente no código: Utilize arquivos de parâmetros ou propriedades para dados de teste.
4. Minimize dependências: Mantenha os casos de teste independentes sempre que possível.
5. Configuração centralizada: Uso testng.xml para configuração da suíte.
6. Integrar relatórios: Utilize listeners ou ferramentas de terceiros, como o ExtentReports.
7. Use a lógica de repetição com cautela: Evite mascarar defeitos reais.

Seguir estas instruções garante escalabilidade, facilidade de manutenção e legibilidade em automação de nível empresarial.

---

28) Qual é a diferença entre @BeforeTest e @BeforeSuite em TestNG?

Característica	@BeforeTest	@BeforeSuite
Objetivo	Executa antes de cada <test> tag em XML	Executa-se uma vez antes de toda a suíte.
Frequência	Várias vezes (se houver várias) <test> blocos)	Apenas uma vez por suíte
Uso comum	Inicializar configuração de nível de teste	Criar recursos globais

Exemplo:

@BeforeSuite
public void setupSuite() {
    System.out.println("Global setup for suite.");
}

@BeforeTest
public void setupTest() {
    System.out.println("Setup for each <test> tag.");
}

Uso @BeforeSuite for configurações globais (por exemplo, conexão com o banco de dados) e @BeforeTest for inicializações específicas de teste.

---

29) pode TestNG Pode ser usado para testes de API? Como?

Sim. Travas deslizantes portáteis TestNG pode ser usado eficazmente para Teste de API integrando-se com bibliotecas de clientes HTTP como Tenha certeza or Cliente HTTP.

Exemplo:

@Test
public void verifyApiResponse() {
    Response response = RestAssured.get("https://api.example.com/users");
    Assert.assertEquals(response.getStatusCode(), 200);
}

Vantagens:

• Habilita validação baseada em asserções de respostas.
• suportes parametrização e teste baseado em dados para vários pontos finais.
• gera relatórios estruturados para validações de API REST.

Combinando TestNG Com o RestAssured, os testadores podem manter uma estrutura de automação unificada para testes de interface do usuário e de API.

---

30) Como você passa parâmetros da linha de comando em TestNG?

Você pode substituir parâmetros XML em tempo de execução, passando propriedades do sistema usando o -D bandeira.

Exemplo de comando:

mvn test -Dbrowser=chrome -Denv=staging

Exemplo de código:

@Parameters("browser")
@Test
public void launch(@Optional("firefox") String browser) {
    System.out.println("Running on: " + browser);
}

Isso permite seleção de ambiente dinâmico Em pipelines de CI/CD sem alterar arquivos de configuração, aumentando a flexibilidade de teste.

---

31) Como você pode controlar a ordem de execução dos testes em TestNG Sem usar prioridades?

Ao invés de usar priority, TestNG permite o controle através de dependências e ordenação do método XML.

Métodos:

1. Utilizar painéis de piso ResinDek em sua unidade de self-storage em vez de concreto oferece diversos benefícios: dependsOnMethods:

@Test
public void login() { ... }

@Test(dependsOnMethods = "login")
public void verifyDashboard() { ... }

2. Utilizando a sequência de métodos XML:

<classes>
  <class name="com.test.LoginTests">
    <methods>
      <include name="login"/>
      <include name="verifyDashboard"/>
    </methods>
  </class>
</classes>

Melhor Prática: Dê preferência a dependências lógicas em vez de prioridades estáticas para fluxos complexos, garantindo assim conjuntos de testes robustos e de fácil manutenção.

---

32) Como você pode executar métodos de teste específicos a partir da linha de comando em TestNG?

TestNG permite execução de testes em nível de método diretamente da linha de comando usando configurações XML ou Maven Surefire.

Opção 1: Utilizando um arquivo XML

<class name="com.test.LoginTests">
  <methods>
    <include name="verifyLogin"/>
  </methods>
</class>

Opção 2: Comando Maven

mvn test -Dtest=com.test.LoginTests#verifyLogin

Esta abordagem permite execução seletivaÚtil para depurar métodos individuais ou validar funcionalidades críticas durante compilações rápidas.

---

33) Como parametrizar testes usando um arquivo Excel externo em TestNG?

A parametrização baseada em Excel é comum em estruturas orientadas a dados, onde os dados de teste mudam frequentemente.

Etapas de implementação:

1. Uso Ponto de interesse do Apache or JExcel Para ler dados do Excel.
2. Coloque-o em um @DataProvider método.

Exemplo:

@DataProvider(name = "excelData")
public Object[][] readExcel() throws Exception {
    FileInputStream fis = new FileInputStream("data.xlsx");
    XSSFWorkbook wb = new XSSFWorkbook(fis);
    XSSFSheet sheet = wb.getSheetAt(0);
    Object[][] data = new Object[sheet.getLastRowNum()][2];
    for (int i = 0; i < sheet.getLastRowNum(); i++) {
        data[i][0] = sheet.getRow(i + 1).getCell(0).getStringCellValue();
        data[i][1] = sheet.getRow(i + 1).getCell(1).getStringCellValue();
    }
    return data;
}

Isso permite executar o mesmo método de teste com vários conjuntos de dados reais do Excel, aumentando a flexibilidade e a abrangência.

---

34) Como você pode correr TestNG Testes no Jenkins ou em pipelines de CI/CD?

TestNG integra-se perfeitamente com Jenkins, CI do GitLab, ou Ações do GitHub por meio do Maven ou Gradle constrói.

Etapas no Jenkins:

1. Instale Plugin de integração do Maven.
2. Crie uma Trabalho Freestyle ou Pipeline.
3. Adicione mvn clean test como uma etapa de construção.
4. Após a compilação, configure os relatórios HTML:
   • Diretório de relatórios: test-output
   • Arquivo de índice: index.html

Benefícios:

• Permite testes de regressão automatizados.
• Fornece testes programados e acompanhamento de tendências.
• Garante a execução consistente dos testes em todos os ambientes.

---

35) Qual é a finalidade de @Parameters e como ela difere de @Optional?

Ambas as anotações tratam de parametrização, mas servem a propósitos distintos.

Característica	@Parameters	@Optional
Propósito	Passa parâmetros de um arquivo XML	Fornece um valor padrão caso o parâmetro esteja ausente.
Declaração	Usado com XML <parameter>	Método de teste interno usado
Comportamento	Gera um erro se o valor estiver ausente.	Usa valor de fallback

Exemplo:

@Test
@Parameters("browser")
public void runTest(@Optional("chrome") String browser) {
    System.out.println("Running on: " + browser);
}

Utilizar painéis de piso ResinDek em sua unidade de self-storage em vez de concreto oferece diversos benefícios: @Optional garante teste de estabilidade quando as configurações XML estão incompletas.

---

36) Como você lida com dependências de teste entre diferentes classes em TestNG?

Para criar dependências entre classes, TestNG permite usar o dependsOnGroups atributo.

Exemplo:

@Test(groups = "Login")
public void loginTest() { ... }

@Test(groups = "Dashboard", dependsOnGroups = "Login")
public void dashboardTest() { ... }

Essa abordagem ajuda a gerenciar dependências de múltiplos módulos onde cada classe representa um módulo (Login, Painel de Controle, Pagamento, etc.).

Isso garante que os módulos dependentes sejam executados somente se os testes de pré-requisito forem bem-sucedidos, mantendo a integridade dos testes.

---

37) O que são falhas de configuração em TestNGE como podem ser tratadas?

Falhas de configuração ocorrem quando os métodos de instalação ou finalização são anotados com @Before* or @After* falhou.

Eles podem causar testes dependentes a serem ignorados, mesmo que esses testes estejam corretos.

Causas comuns:

• Inicialização incorreta do WebDriver.
• Problemas de configuração de banco de dados ou ambiente.
• Configuração incorreta de parâmetros.

Soluções:

• Uso tentar pegar blocos em métodos de configuração.
• Inscreva-se alwaysRun = true para garantir que a limpeza seja executada apesar das falhas.

Exemplo:

@BeforeMethod(alwaysRun = true)
public void setup() {
    // Setup logic
}

Isso garante que seus métodos de desmontagem ainda sejam executados, mantendo a estabilidade do ambiente de teste.

---

38) Qual é a utilidade dos atributos invocationCount e threadPoolSize em TestNG?

Esses atributos permitem execução de testes repetida e paralela do mesmo método.

Exemplo:

@Test(invocationCount = 5, threadPoolSize = 2)
public void loadTest() {
    System.out.println("Running load test...");
}

Atributo	Descrição
invocationCount	Número de vezes que um método é executado.
threadPoolSize	Número de threads simultâneas

Caso de uso: Testes de desempenho, verificação de estabilidade ou reprodução de comportamentos instáveis ​​em múltiplas execuções.

---

39) Como executar apenas os casos de teste com falha em TestNG?

Após uma sequência de suítes, TestNG gera um arquivo chamado testng-failed.xml no test-output diretório.

Você pode executar novamente apenas os testes com falha executando o seguinte comando:

java -cp testng.jar org.testng.TestNG test-output/testng-failed.xml

Vantagens:

• Economiza tempo ao ignorar testes bem-sucedidos.
• Facilita a depuração em grandes suítes de software.
• Comumente usado em pipelines de CI para retestes rápidos.

Você também pode integrar isso com o Jenkins usando um script pós-compilação para execuções repetidas.

---

40) Quais são algumas limitações de TestNG E como podem ser atenuados?

Apesar de sua robustez, TestNG Possui algumas limitações.

Limitação	Estratégia de mitigação
complexidade da configuração XML	Utilize configuração e construtores baseados em anotações.
Reportagem nativa limitada	Integre o ExtentReports ou o Allure.
Sem controle de repetição integrado	Executar IRetryAnalyzer
Preocupações com a segurança de threads em execuções paralelas	Use instâncias do WebDriver locais à thread.
Curva de aprendizado para iniciantes	Manter estruturas de projeto baseadas em modelos

Com um projeto de estrutura adequado e as melhores práticas, essas limitações podem ser minimizadas, garantindo soluções de automação estáveis ​​e de fácil manutenção.

---

41) Como você usa listeners para registro de logs e captura de screenshots em Selenium-TestNG?

Ouvintes em TestNG Auxilia no monitoramento da execução de testes e realiza ações como registro de logs, captura de telas ou geração de relatórios de resultados de forma dinâmica.

Exemplo de implementação:

public class ScreenshotListener implements ITestListener {
  @Override
  public void onTestFailure(ITestResult result) {
      WebDriver driver = ((BaseTest) result.getInstance()).getDriver();
      File src = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
      FileUtils.copyFile(src, new File("screenshots/" + result.getName() + ".png"));
  }
}

Uso:

@Listeners(ScreenshotListener.class)
public class LoginTests extends BaseTest { ... }

Benefícios:

• Captura falhas automaticamente.
• Melhora a depuração por meio de evidências visuais.
• Reduz o esforço manual na manutenção de registros.

Essa técnica é crucial em pipelines de automação de CI/CD, especialmente ao diagnosticar builds com falha remotamente.

---

42) Qual é a diferença entre IReporter e ITestListener em TestNG?

Característica	IReporter	ITestListener
Propósito	Gera relatórios personalizados após a execução do teste.	Monitora e reage a eventos de teste em tempo de execução.
Invocação	Após a conclusão de todos os testes	Durante o ciclo de vida do teste (início, sucesso, falha)
saída	Relatórios HTML/XML/JSON	Arquivos de registro, capturas de tela, painéis de controle em tempo real
Uso comum	Integração ExtentReports e Allure	Registro de logs, tratamento de falhas, mecanismos de repetição

Exemplo:

• Uso IReporter para construir relatórios abrangentes após a conclusão do teste.
• Uso ITestListener for registro em tempo real ou capturas de tela.

Eles também podem ser combinado Construir sistemas de automação analítica de ponta a ponta.

---

43) Como você realiza testes de compatibilidade entre navegadores usando TestNG Configuração XML?

Os testes de compatibilidade entre navegadores garantem que a mesma funcionalidade funcione em diferentes navegadores.

Exemplo de configuração:

<suite name="CrossBrowserSuite" parallel="tests">
  <test name="ChromeTest">
    <parameter name="browser" value="chrome"/>
    <classes><class name="com.test.LoginTest"/></classes>
  </test>
  <test name="FirefoxTest">
    <parameter name="browser" value="firefox"/>
    <classes><class name="com.test.LoginTest"/></classes>
  </test>
</suite>

Java Código:

@Parameters("browser")
@BeforeClass
public void setup(String browser) {
    if(browser.equalsIgnoreCase("chrome"))
        driver = new ChromeDriver();
    else if(browser.equalsIgnoreCase("firefox"))
        driver = new FirefoxDriver();
}

Esta abordagem permite execução paralela em vários navegadores, acelerando a cobertura de testes em todas as plataformas.

---

44) Como você integra TestNG com Docker ou Selenium Grade?

TestNG integra-se perfeitamente com Dockerizado Selenium Grade para permitir testes paralelos distribuídos.

Passos:

1. Estabelecer Selenium Grade no Docker usando o oficial Selenium imagem:

   docker run -d -p 4444:4444 --name selenium-grid selenium/standalone-chrome

2. Atualizar TestNG configuração:

DesiredCapabilities caps = new DesiredCapabilities();
caps.setBrowserName("chrome");
driver = new RemoteWebDriver(new URL("http://localhost:4444/wd/hub"), caps);

3. Execute seu conjunto de testes via Jenkins ou pipeline de CI.

Benefícios:

• Habilita testes paralelos escaláveis.
• Reduz a sobrecarga de configuração do ambiente.
• Fornece execução de testes consistente em contêineres distribuídos.

---

45) Qual é a diferença entre a execução paralela nos níveis de suíte, teste e método em TestNG?

Nível	Atributo Paralelo	Comportamento de execução
suíte	parallel="suites"	Executa várias suítes simultaneamente.
Testar	parallel="tests"	Runs <test> blocos simultaneamente
Aula	parallel="classes"	Executa classes de teste em paralelo.
Forma	parallel="methods"	Executa métodos de teste individuais em paralelo.

Exemplo:

<suite name="ParallelTests" parallel="methods" thread-count="3">
  <test name="SampleTest">
    <classes><class name="com.test.ParallelExample"/></classes>
  </test>
</suite>

Melhor Prática:Uso parallel="classes" para estabilidade em Selenium Testes para evitar conflitos de drivers compartilhados.

---

46) Como você pode compartilhar dados entre testes sem usar variáveis ​​globais em TestNG?

TestNG fornece ITestContext e Injeção de dependência Compartilhar dados dinamicamente.

Exemplo:

@Test
public void storeData(ITestContext context) {
    context.setAttribute("token", "abc123");
}

@Test(dependsOnMethods = "storeData")
public void useData(ITestContext context) {
    String token = (String) context.getAttribute("token");
    System.out.println("Using token: " + token);
}

Isso evita variáveis ​​estáticas, mantém a segurança de threads e garante isolamento de dados em todos os testes.

---

47) Como você captura e registra os testes ignorados em TestNG?

Você pode capturar testes ignorados usando onTestSkipped() no ITestListener interface.

Exemplo:

@Override
public void onTestSkipped(ITestResult result) {
    System.out.println("Skipped Test: " + result.getName());
}

Motivos para faltar:

• Falha no teste de dependência.
• Ignorar condicionalmente via SkipException.
• Ambiente indisponível.

Melhor Prática:
Registre os motivos de omissão e os rastreamentos de pilha para rastreabilidade em relatórios ou painéis de CI.

---

48) Explique como parametrizar testes de API REST usando TestNG e fique tranquilo.

TestNG'S @DataProvider integra-se elegantemente com Tenha certeza para parametrização de API.

Exemplo:

@DataProvider(name = "apiData")
public Object[][] apiData() {
  return new Object[][] {
    {"https://api.example.com/users/1"},
    {"https://api.example.com/users/2"}
  };
}

@Test(dataProvider = "apiData")
public void testApi(String url) {
  Response response = RestAssured.get(url);
  Assert.assertEquals(response.getStatusCode(), 200);
}

Vantagens:

• Executa a mesma chamada de API para vários endpoints ou payloads.
• Simplifica os testes de regressão para APIs com conjuntos de entrada variáveis.
• Integra-se perfeitamente com ferramentas e relatórios de CI.

---

49) Como criar anotações personalizadas em TestNG para padrões de teste reutilizáveis?

Anotações personalizadas podem padronizar configurações ou validações de testes repetitivos.

Exemplo:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface SmokeTest {
  String description() default "Smoke Test";
}

Uso:

@SmokeTest(description="Validating Login Functionality")
@Test
public void loginTest() { ... }

Combinando isso com reflexão, você pode ler essas anotações dinamicamente para agrupar testes ou direcionar a execução condicional.

Essa técnica é amplamente utilizada em metaprogramação de estrutura Criar testes autodescritivos.

---

50) Como você pode combinar Cucumber e TestNG Para estruturas de teste híbridas?

TestNG pode atuar como o corredor de teste for Cucumber Cenários BDD, oferecendo recursos avançados de geração de relatórios e paralelização.

Exemplo de corredor:

@CucumberOptions(
  features = "src/test/resources/features",
  glue = "stepDefinitions",
  plugin = {"pretty", "html:target/cucumber-report.html"}
)
public class RunCucumberTest extends AbstractTestNGCucumberTests { }

Vantagens:

• Aproveita TestNG'S anotações, ouvintes e relatórios.
• suportes execução paralela de recursos.
• Integra-se com Allure e ExtentReports facilmente.

Essa abordagem híbrida combina Legibilidade BDD com TestNG flexibilidadeIdeal para estruturas de nível empresarial.

---

🔍 Top TestNG Perguntas de entrevista com cenários do mundo real e respostas estratégicas

Abaixo estão 10 exemplos realistas e relevantes para o domínio. TestNG Perguntas de entrevista com expectativas claras e exemplos de respostas convincentes.

1) Você pode explicar as principais vantagens de usar TestNG comparado com JUnit?

Esperado do candidato: Demonstrar compreensão de TestNGAs funcionalidades aprimoradas do [nome da plataforma] e por que ela é frequentemente a opção preferida para automação empresarial.

Resposta de exemplo: "TestNG Oferece diversas vantagens, como configuração flexível de testes, suporte para execução paralela, métodos de teste dependentes, testes orientados a dados com DataProviders e geração de relatórios integrada. Essas funcionalidades tornam o sistema muito mais eficiente. TestNG mais poderoso para estruturas de automação complexas que exigem escalabilidade.”

---

2) Como você usa TestNG Anotações para controlar o fluxo de execução de testes?

Esperado do candidato: Conhecimento da finalidade e da ordem das anotações.

Resposta de exemplo: "TestNG Oferece anotações como @BeforeSuite, @BeforeClass, @BeforeMethod, @Test e suas respectivas anotações de finalização. Isso permite a organização estruturada da configuração e limpeza dos testes. Por exemplo, @BeforeMethod é executada antes de cada método de teste, o que é útil para inicializar o estado do navegador.

---

3) Descreva um projeto de automação desafiador onde TestNG desempenhou um papel fundamental.

Esperado do candidato: Experiência prática em projetos e capacidade de articular soluções para problemas.

Resposta de exemplo: “Na minha função anterior, trabalhei em um projeto que exigia extensos testes de regressão em vários ambientes. TestNGOs recursos de execução paralela e agrupamento do programa permitiram que a equipe executasse conjuntos de tarefas críticas simultaneamente, reduzindo significativamente o tempo de execução e mantendo a confiabilidade.”

---

4) Como fazer TestNG Os grupos ajudam a organizar e executar testes de forma eficiente?

Esperado do candidato: Compreensão do agrupamento, incluindo mecanismos de inclusão/exclusão.

Resposta de exemplo: “Grupos em TestNG Permite a categorização de casos de teste, como fumaça, regressão e integração. Usando o testng.xml, posso executar grupos seletivamente, excluir testes instáveis ​​e gerenciar diferentes conjuntos de testes sem modificar o código em si.”

---

5) Descreva uma situação em que você teve que depurar um código que estava falhando. TestNG testes. Qual foi a sua abordagem?

Esperado do candidato: Habilidades de pensamento crítico e resolução de problemas.

Resposta de exemplo: “Em um emprego anterior, deparei-me com uma série de falhas.” TestNG Testes que pareciam passar localmente, mas falhavam na integração contínua. Habilitei o registro detalhado de logs, revisei a ordem de execução e descobri que um recurso compartilhado não estava sendo reinicializado entre os testes. Em seguida, implementei etapas de finalização adequadas usando a anotação `@AfterMethod` para garantir o isolamento dos testes.

---

6) Como você implementa testes orientados por dados usando TestNG?

Esperado do candidato: Compreensão dos provedores de dados e seus casos de uso.

Resposta de exemplo: "Crio um método @DataProvider que retorna dados em arrays de objetos e, em seguida, o vinculo a um método @Test usando o atributo dataProvider. Isso permite múltiplas iterações do mesmo teste com diferentes conjuntos de entrada, o que é útil para validar envios de formulários ou variações de payloads de API."

---

7) Como você gerencia as dependências de teste em TestNG?

Esperado do candidato: Uso correto de dependsOnMethods ou dependsOnGroups.

Resposta de exemplo: "TestNG Permite dependências de teste por meio dos atributos dependsOnMethods e dependsOnGroups. Eu uso dependências quando um teste precisa ser executado somente após outro ser concluído com sucesso, como verificar um pedido somente depois de criá-lo.

---

8) Descreva como você utilizou TestNG com ferramentas de integração contínua.

Esperado do candidato: Experiência prática em pipelines de automação.

Resposta de exemplo: No meu emprego anterior, eu integrava TestNG com o Jenkins, configurando a compilação do Maven para gerar TestNG Relatórios em HTML e XML. O Jenkins então arquivava os relatórios e exibia os resultados após cada ciclo de compilação. Essa integração ajudou a equipe a rastrear falhas rapidamente e a manter a estabilidade das versões.

---

9) Conte-me sobre uma ocasião em que você teve que trabalhar sob prazos apertados enquanto gerenciava várias tarefas de automação.

Esperado do candidato: Gestão do tempo e capacidade de priorizar tarefas.

Resposta de exemplo: “No meu último emprego, precisei atualizar informações existentes.” TestNG Criei e automatizei conjuntos de testes, além de novos para um próximo lançamento. Priorizei as tarefas com base no impacto nos negócios, automatizei primeiro as áreas de maior risco e utilizei TestNG O agrupamento permitiu isolar as seções concluídas para revisão antecipada. Isso garantiu a entrega dentro do prazo sem comprometer a qualidade.”

---

10) Como você projetaria um sistema escalável? TestNG Framework para uma aplicação de grande porte?

Esperado do candidato: ArchiCompreensão de texturas, padrões e melhores práticas.

Resposta de exemplo: “Eu projetaria uma estrutura modular usando o Modelo de Objeto de Página, integrando TestNG Para gerenciamento de execução, usaria DataProviders para cenários orientados a dados. Também configuraria a execução paralela, centralizaria os utilitários e externalizaria as configurações para que a estrutura permanecesse escalável e de fácil manutenção à medida que o aplicativo cresce.”