Grupos em TestNG

Por: Krishna Degrau Krishna Degrau
Hours Atualização do

⚡ Resumo Inteligente

Grupos em TestNG Permite marcar métodos de teste com rótulos lógicos e, em seguida, incluí-los ou excluí-los por meio de um conjunto de testes XML. Essa abordagem simplifica a execução de testes de fumaça, regressão e orientados a dependências sem a necessidade de reescrevê-los. Java código.

  • 🏷️ Sintaxe de anotação: Uso @Test(groups = {"smoke","regression"}) Para marcar qualquer método com um ou mais nomes de grupos lógicos.
  • 📜 Controle XML: O <groups><run><include> e <exclude> As tags dentro do arquivo testng.xml determinam quais métodos marcados serão executados.
  • 🔗 Dependências: O dependsOnGroups O atributo força a ordenação de forma que os grupos de pré-requisitos sempre terminem antes que os testes dependentes comecem.
  • 🤖 Seleção por IA: As ferramentas de IA para análise de impacto de testes mapeiam as alterações de código para os grupos relevantes, de forma que apenas os conjuntos de testes afetados sejam executados a cada commit.
  • 🧪 TestNG 7.x: As versões modernas mantêm os grupos totalmente compatíveis com execução paralela, listeners e pipelines do Maven Surefire.
Saiba Mais

Grupos em TestNG

TestNG é uma estrutura de testes que abrange testes de unidade, funcionais, de ponta a ponta, de interface do usuário e de integração para Java projetos.

Você pode executar um único pacote ou vários pacotes (um pacote encapsula classes relacionadas em um layout de diretório definido) criando um conjunto de arquivos XML e acionando-o por meio do Maven.

TestNG Grupos com exemplo

Você usa grupos em TestNG quando:

  • Você não quer espalhar métodos de teste por várias classes simplesmente por área funcional, e
  • Você deseja ignorar (não executar) casos de teste selecionados como se eles não existissem no código-fonte.
  • Para atingir ambos os objetivos, você categoriza os métodos em grupos lógicos. TestNG Em seguida, respeita os filtros "include" e "exclude" declarados no conjunto XML.

O trecho de código abaixo mostra a sintaxe de marcação de grupo usada em um método de teste.

@Teste (grupos = { “laços”, “laços fortes” })

Aqui são usados ​​dois nomes de grupo, a saber: bonding e strong_tiesEssas são etiquetas lógicas que você pode renomear para se adequarem ao seu projeto.

O <groups> A tag marca o início dos filtros de grupo dentro do conjunto XML.

Em seguida, você personaliza o XML para selecionar um grupo específico dentre as classes marcadas. O exemplo abaixo mostra a sintaxe da declaração de grupo.

<grupos>
<corrida>
<incluir nome=“laços” />
</corrida>
</grupos>

Considere que uma única classe contém 10 métodos de teste.

Dentre esses métodos:

  • 6 métodos carregam o bonding grupo, e
  • 4 métodos carregam o strong_ties grupo.

Em seguida, você configura o Maven e Java caminhos e use o Eclipse IDE para demonstrar o uso em grupo por meio de arquivos XML dentro de um Java-projeto baseado em Maven.

ARTIGOS RELACIONADOS

Criar XML para TestNG com etiquetas

  • O arquivo XML (Extensible Markup Language) no framework Maven armazena a configuração para um ou mais testes, declarados dentro do tag.
  • Cada entrada de teste é envolvida em um etiqueta e pode conter um ou mais TestNG classes.
  • A Java aula com um ou mais @Teste As anotações sobre seus métodos são tratadas como uma TestNG classe.

Várias tags aparecem em sequência para construir um arquivo testng.xml funcional, a saber: , , e .

  • O A tag contém o nome do nível da suíte usado em TestNG relatórios para resumos de execução.
  • O <test name=”Guru 99 Teste de Fumaça”> A tag contém um nome de teste lógico; o relatório a utiliza para contabilizar aprovações, reprovações e testes ignorados, além do tempo total de execução e metadados do grupo.
  • O A tag aponta para a classe de teste, onde com.group.guru99 é o pacote e TC_Class1 é o nome da classe.

<!DOCTYPE suíte SISTEMA “http://testng.org/testng-1.0.dtd”>
<suíte nome="Suíte">
<teste nome="Guru 99 Teste de Fumaça - Demonstração">
<grupos>
<corrida>
<incluir nome=“laços fortes” />
</corrida>
</grupos>
<aulas>
<classe nome=“com.group.guru99.TC_Class1” />
</aulas>
</teste>
</suíte>

Esta configuração XML é referenciada nos tutoriais em vídeo das próximas seções.

“excluir” ou “incluir” no XML de teste

Se o mecanismo de agrupamento parecer complexo demais para um filtro pequeno, o conjunto de ferramentas testng.xml também permite excluir ou incluir métodos de teste individuais por nome.

Excluir etiquetaSintaxe para a tag de exclusãoexcluir nome=“${TEST_CASE_NAME}” />
Incluir etiquetaSintaxe para a tag de inclusãoincluir nome=“${TEST_CASE_NAME}” />

Observação: Você pode incluir ou excluir vários casos de teste em uma única execução, e a mesma sintaxe se aplica aos filtros de grupo.

Utilizando dependsOnGroups para Execução Ordenada

Além da simples inclusão, TestNG permite que um grupo dependa de outro usando o dependsOnGroups atributo. O executor garante que todos os métodos no grupo pai terminem antes que qualquer método dependente seja iniciado, o que mantém as pré-condições confiáveis.

  • Primeiro faça login e depois realize as transações: Métodos de login com tags group = "auth"e testes de transferência de etiquetas com dependsOnGroups = {"auth"}Os testes de transferência são executados somente após o login ser bem-sucedido.
  • Ignorar em caso de falha: Se um método no grupo pai falhar, TestNG Marca os métodos dependentes como ignorados em vez de os falhar completamente, o que mantém os relatórios honestos.
  • Combine com alwaysRun: Os métodos de limpeza devem ser configurados. alwaysRun = true Assim, o processo de desmontagem continua sendo executado mesmo quando um grupo upstream falha.

Esse padrão é comum em suítes de testes ponta a ponta, onde a configuração da API precisa ser concluída antes que as verificações da interface do usuário sejam iniciadas.

Execute TestNG Agrupar, incluir, excluir código (demonstração em vídeo)

A seguir, um passo a passo do Java código e o conjunto XML que impulsionam o agrupar, excluir e incluir comportamento.

Cenário de teste: Lançar o GuruSite de demonstração bancária 99: verifique alguns elementos na página de login, insira as credenciais e verifique novamente alguns itens no painel após o login.

Execute TestNG Agrupar, Incluir, Excluir Code

Observação: Cada etapa reside em seu próprio método, mas em tempo de execução a ordem depende das entradas no conjunto XML.

  • Método 1: Inicialize o navegador e inicie o URL (tc01LaunchURL()).
  • Método 2: Verifique o cabeçalho da página de login (tc02VerifyLaunchPage()).
  • Método 3: Insira o nome de usuário e a senha no formulário de login (tc03EnterCredentials()).
  • Método 4: Verifique a presença do ID do gerente no painel do usuário (tc04VerifyLoggedInPage()).
  • Método 5: Verifique os links adicionais no painel do usuário (tc05VerifyHyperlinks()).

Code para o cenário:

pacote com.group.guru99;

importar java.util.concurrent.TimeUnit;

importar org.openqa.selenium.By;
importar org.openqa.selenium.WebDriver;
importar org.openqa.selenium.firefox.FirefoxMotoristas;
importar org.testng.Assert;
importar org.testng.annotations.Test;

aula pública TC_Classe1 {
final estática pública webdriver webDriver = new FirefoxDirigir();

Tanga cabeçalhoDaPáginaDeLançamento = “//h3[text()='Guru99 Bank']”;
final Tanga elemento_nome_de_usuário = “//input[@name='uid']”, elemento_senha = “//input[@name='password']”,
elemento_de_entrada = “//input[@name='btnLogin']”;
final Tanga valor_userName = “mngr28642”, valor_da_senha = “ydAnate”;
final Tanga ID do gerente = “//td[contains(text(),'ID do Gerente')]”;
final Tanga novoCliente = “//a[@href='addcustomerpage.php']”, transferênciaDeFundos = “//a[@href='FundTransInput.php']”;

/** Este caso de teste inicializa o webDriver */
@Teste(grupos = { “laços”, “laços fortes” })
vazio público tc01LançamentoURL() {
webDriver.manage().window().maximize();
webDriver.manage().timeouts().implicitlyWait(20, TimeUnit.SEGUNDOS);
webDriver.get(“https://www.demo.guru99.com/V4/”);
}

/** Verifica a presença do cabeçalho na página de login */
@Teste(grupos = { “laços” })
vazio público tc02VerifyLaunchPage() {
Assert.assertTrue(webDriver.findElement(By.xpath(launchPageHeading)).isDisplayed(),
O cabeçalho da página inicial não está sendo exibido.);
System.out.println(“O cabeçalho da página inicial está sendo exibido”);
}

/** Insere o nome de usuário, a senha e clica em Entrar */
@Teste(grupos = { “laços”, “laços fortes” })
vazio público tc03EnterCredentials() {
webDriver.findElement(By.xpath(userName_element)).sendKeys(userName_value);
webDriver.findElement(By.xpath(password_element)).sendKeys(password_value);
webDriver.findElement(By.xpath(signIn_element)).click();
}

/** Verifica o ID do gerente no painel de controle */
@Teste(grupos = { “laços fortes” })
vazio público tc04VerifyLoggedInPage() {
Assert.assertTrue(webDriver.findElement(By.xpath(managerID)).isDisplayed(),
“A etiqueta de identificação do gerente não está sendo exibida”);
System.out.println(“A etiqueta de identificação do gerente está sendo exibida”);
}

/** Verifica o link de novo cliente e o link de transferência de fundos no painel de controle */
@Teste(grupos = { “laços” })
vazio público tc05VerificarHiperlinks() {
Assert.assertTrue(webDriver.findElement(By.xpath(newCustomer)).isEnabled(),
O link para "Novo cliente" não está sendo exibido.);
System.out.println(“Exibido o hiperlink para novo cliente”);

Assert.assertTrue(webDriver.findElement(By.xpath(fundTransfer)).isEnabled(),
O link para transferência de fundos não está sendo exibido.);
System.out.println(“O link para transferência de fundos é exibido”);
}
}

Atenção: as credenciais bancárias de demonstração permanecem válidas por aproximadamente 20 dias, portanto, uma execução local pode exibir um erro de credenciais inválidas após esse período expirar.

Explicação do código:

Cinco métodos de teste, um por ação, cada um com um groups atributo no @Test anotação.

Os dois rótulos de grupo lógico são strong_ties e bonding.

  • O primeiro e o terceiro métodos carregam ambos bonding e strong_tiesPortanto, elas são executadas sempre que qualquer um dos grupos estiver incluído no conjunto de testes. Esse é um padrão comum para sistemas compartilhados. caso de teste passos.
  • O segundo método está marcado apenas com bonding, então ele só funciona quando o bonding O grupo está incluído.
  • O quarto método está marcado apenas com strong_tiesPortanto, ele só é executado quando esse grupo está incluído.
  • O quinto método está marcado apenas com bonding, então ele só funciona quando o bonding O grupo está incluído.

Seguem-se quatro cenários de execução:

Cenário 1: Execute todos os métodos de teste, independentemente do grupo. Remova o <groups> bloco do XML em execução.

Cenário 2: Execute apenas os métodos associados a um grupo escolhido, a saber: strong_ties or bondingPor favor, veja o vídeo abaixo.

  • Na primeira parte do vídeo, o <groups> O bloco está comentado, então todos os métodos de teste são executados.
  • Na segunda parte, o filtro de grupo é restaurado e apenas os métodos correspondentes são executados.

Cenário 3: Aplique o filtro de exclusão para ignorar casos de teste selecionados. Consulte o vídeo.

  • A demonstração exclui tc02 pelo nome no XML em execução, e o relatório de resultados confirma que o método excluído não é executado.

Cenário 4: Aplique o filtro de inclusão para executar somente tc01LaunchURL, tc03EnterCredentials e tc05VerifyHyperlinksPor favor, consulte o vídeo.

Nessa execução, somente os métodos listados no filtro de inclusão são executados, exatamente como configurado.

Faça o download do projeto de exemplo no link abaixo.

Faça o download do arquivo acima. Code

Conclusão

Grupos em TestNG dar estrutura a grandes Selenium e conjuntos de unidades, substituindo divisões de classe pontuais por filtros XML declarativos.

Identifique seus métodos com @Test(groups = {...}), então use <include>, <exclude> e dependsOnGroups para gerar testes de fumaça, regressão e ponta a ponta a partir do mesmo projeto Maven em TestNG 7.x.

Perguntas Frequentes

Um grupo é um rótulo lógico atribuído a um método de teste por meio do groups atributo em @TestO conjunto de ferramentas XML seleciona grupos usando filtros de inclusão e exclusão, permitindo que você decida em tempo de execução quais métodos marcados serão executados.

Dentro da <groups><run>, <include name="..."> A tag lista grupos permitidos para a execução, e <exclude name="..."> bloqueia-os. TestNG A função `excludes` aplica-se após a função `includes`, portanto, um grupo excluído é sempre ignorado, mesmo quando também está listado na função `includes`.

O dependsOnGroups atributo em @Test forças TestNG Executar todos os métodos do grupo listado antes do início do método dependente. Se algum método pré-requisito falhar, TestNG marca o método dependente como ignorado em vez de falho.

Sim. O groups O atributo aceita um array, então @Test(groups = {"smoke", "regression"}) Coloca um método em ambos os grupos. TestNG Executa esse método sempre que qualquer um dos grupos estiver incluído no conjunto de tarefas, o que mantém as etapas compartilhadas livres de repetição.

TestNG A versão 7.x é a linha com suporte, com lançamentos sob a categoria org.testng:testng Coordenadas do Maven. Mantém grupos, execução paralela e listeners totalmente compatíveis com as tecnologias modernas. Selenium Projetos 4 e JDK 17.

Ferramentas de IA para análise de impacto de testes analisam as diferenças de código e mapeiam as classes alteradas para os grupos que as abrangem. O pipeline executa apenas os grupos marcados em cada solicitação de pull request, reduzindo o tempo de feedback e mantendo a qualidade.ping Caminhos arriscados em teste.

Sim. Os algoritmos de agrupamento de IA leem registros históricos de falhas, sinalizam testes instáveis ​​e propõem um subconjunto estável etiquetado como regressionOs engenheiros aprovam a lista, então TestNG Executa esse grupo todas as noites, o que mantém a suíte segura sem perder a cobertura.

Resuma esta postagem com: