Testng: A anotação @Test (enabled = false) no nível da classe deve desabilitar todos os métodos da classe

Oi Nicolas,

Você deve ver isso se não usar nenhum método @Test em seus métodos, mas assim que o fizer (como você fez em seu exemplo acima com dataProvider), o atributo enabled será substituído e seu padrão é verdade, daí o comportamento que você está vendo.

Isso faz sentido?

Sim, obrigado Cedric.

Eu faço a suposição errada de que a anotação @test (enabled = false) na classe exclui inteiramente a classe da execução

Eu concordo que é um pouco contra-intuitivo, mas é tarde demais para mudar agora, infelizmente ...

Oi, Cedric!
Que tal adicionar um novo parâmetro à anotação @Test e chamá-lo de algo como "enabledClass" e torná-lo verdadeiro por padrão? Deve ser usado apenas em um nível de classe (enabledClass = false) para desabilitar toda a classe, independentemente das anotações de nível de método, e ser ignorado, se adicionado para o método.
Desta forma, preservaríamos a compatibilidade com versões anteriores e forneceríamos uma funcionalidade bastante útil ao mesmo tempo.
Se desejar, posso implementá-lo sozinho e fornecer uma solicitação pull.
Desde já, obrigado!

@ andronix83 ,

Receio que isso torne as coisas mais confusas agora que você precisa explicar a diferença sutil entre enabled e enabledClass .

O comportamento atual de enabled não é o mais intuitivo, mas não parece ser um problema em geral, se eu julgar pelo número de vezes que esse problema foi levantado (quase nunca).

Olá Cédric,

Na verdade, encontrei esse problema na semana passada. Estou trabalhando em um servidor web que depende da API Graph do Facebook. Eu tive uma classe de teste que tinha alguns métodos de teste que dependiam do código que chegava à API Graph, com outros métodos de teste que não precisavam nem mesmo depender desse serviço. Então, houve uma interrupção global no Facebook como um todo por mais de uma hora. Isso resultou na falha de alguns dos testes desta classe.

O que eu esperava fazer, a fim de manter o resto da minha equipe de desenvolvimento desbloqueado, é apenas desabilitar todos os testes nesta classe imediatamente, por meio de uma anotação @Test (enabled = false) no nível da classe. Claro, isso não funcionou. Em vez disso, tive que desabilitar cada método de teste com falha, um por um, levando mais tempo do que o desejado, ou mesmo o necessário, para resolver o problema.

Idealmente, TestNG suporta algum tipo de funcionalidade semelhante à anotação @Ignore do JUnit: http://junit.sourceforge.net/javadoc/org/junit/Ignore.html. Resumindo, os desenvolvedores realmente desejam essa funcionalidade.

Obrigada.

@ecbrodie Isso já é suportado (experimente!), mas há uma advertência: cada método individual que possui uma anotação @Test reativará o teste.

@Test(enabled = false)
public class T {
  void f() {} // will not run
}

@Test(enabled = false)
public class T {
  <strong i="10">@Test</strong>
  void f() {} // WILL run!
}

Isso se deve à semântica de que os atributos no nível do método substituem os atributos definidos no nível da classe, então o nível do método @Test annotation está basicamente dizendo @Test(enabled = true) pois é o valor padrão ...

Faz sentido?

Olá @cbeust , obrigado por esse exemplo, mas esse já era o entendimento do problema, então acho que você pode ter me entendido mal. Esse ponto que eu estava tentando fazer era, dada a semântica atual de @Test (enabled = true / false) e o desejo de ter uma maneira de realmente especificar uma substituição de enabled no nível da classe para ignorar o que quer que seja definido no método nível, talvez seja hora de reconsiderar sua postura contra a adição de algum tipo de valor de anotação enabledClass .

Você parece indicar algum desdém em relação à abordagem original que adotou com a semântica @Test (habilitada). Se esse for realmente o caso, por que não trazer sua semântica para algo que você acha que é mais intuitivo?

Concordo, acho que @Test(enabledClass = false) faria sentido e é a única maneira de implementar sua sugestão sem quebrar a compatibilidade com versões anteriores. Deve ser muito fácil também.

Talvez você ou @juherr estejam interessados ​​em enviar um PR?

Não estou me sentindo bem. Não gosto da ideia de adicionar um novo atributo que só pode ser usado nas aulas.
Então, eu acho que enable=false é uma prática ruim quando usado no código-fonte porque você terá que modificar os códigos-fonte quando quiser executar os testes.
IMO, se você quiser desmarcar uma classe, testng.xml deve ser usado em seu lugar.
@ecbrodie Como você executa seus testes?

BTW, o que proponho em vez disso é fornecer uma implementação IAnnotationTransformer que irá substituir o comportamento padrão de enable=false na classe.
IAnnotationTransformer tem apenas de enable=false todos os testes se sua classe tem enable=false .
Isso não quebrará a compatibilidade com versões anteriores e não adicionará um parâmetro específico.
@cbeust O que você acha?

@juherr Cool PR, é realmente muito simples de fazer com um IAnnotationTransformer .

Minha única preocupação é que, para o usuário, seja um pouco mais misterioso de usar, ao contrário de um atributo enabledClass .

Observe que já temos alguns atributos que são aplicáveis ​​apenas no nível de classe ( suiteName , testName ).

Como eu disse, não gosto do caso de uso. E suponho que seja o suficiente para as únicas 2 pessoas que o fizeram nos últimos 4 anos :)

@juherr Bastante justo.

@ecbrodie O que você acha do PR?

https://github.com/cbeust/testng/pull/816

@cbeust
Apenas curioso. E se fornecermos um AnnotationTransformer integrado que pode fazer isso?

Sim, é o que o # 816 propõe

@juherr
Obrigado por compartilhar essas informações de RP. Algum motivo para isso estar esperando para ser mesclado?

E se eu tiver um cenário como o abaixo:

@Test(groups = { "regression", "smoke" }, dependsOnGroups = { "Creation" })
public class EditName {

    @Test(dataProvider="SomeTestData",dataProviderClass=SearchData.class)
    public void TC_1(String Msg) throws Exception{
        System.out.println(Msg);
    }

    @Test(dataProvider="SomeTestData",dataProviderClass=SearchData.class, dependsOnMethods = { "TC_1" }))
    public void TC_2(String Msg) throws Exception{
        System.out.println(Msg);
    }
}

1. TC_1 e TC_2 pertencerão a ambos, grupos de regressão e fumaça?
2. TC_1 e TC_2 dependerão do grupo "Criação"?
3. TC_2 será dependente do grupo "Criação", bem como TC_1 ou apenas TC_1?

@ Rameshwar-Juptimath Qual é a relação entre sua amostra e este problema?

Devido a este comportamento não intuitivo de @Test em nível de classe e método.
O que deve ser recomendado como melhor prática?
Devemos evitar o uso de ambos em testes?
Se estamos mais ou menos usando isso no nível do método para ter um provedor de dados diferente para cada caso, devemos evitar tê-lo na classe?
Pensamentos?

@aliciatang O comportamento é o mesmo para todos os atributos de anotação: os valores no método sobrescreverão os valores na classe.

Desde o 6.13, você pode usar @Ignore com o comportamento que você espera. A documentação para @Ignore pode ser encontrada aqui