Gradle - Teste

A tarefa de teste detecta e executa automaticamente todos os testes de unidade no conjunto de origem de teste. Ele também gera um relatório quando a execução do teste é concluída. JUnit e TestNG são as APIs com suporte.

A tarefa de teste fornece um Test.getDebug()método que pode ser configurado para iniciar para fazer a JVM esperar por um depurador. Antes de prosseguir com a execução, ele define a postagem do depurador para5005.

Detecção de Teste

o Test Taskdetecta quais classes são classes de teste inspecionando as classes de teste compiladas. Por padrão, ele verifica todos os arquivos .class. Você pode definir inclusões / exclusões personalizadas, apenas essas classes serão verificadas. Dependendo da estrutura de teste usada (JUnit / TestNG), a detecção da classe de teste usa critérios diferentes.

Ao usar o JUnit, examinamos as classes de teste JUnit 3 e 4. Se algum dos seguintes critérios corresponder, a classe é considerada uma classe de teste JUnit -

  • Classe ou superclasse estende TestCase ou GroovyTestCase
  • Classe ou superclasse é anotada com @RunWith
  • Classe ou superclasse contém um método anotado com @Test
  • Ao usar TestNG, verificamos métodos anotados com @Test

Note- As classes abstratas não são executadas. O Gradle também verifica a árvore de herança em arquivos jar no classpath de teste.

Se não quiser usar a detecção de classe de teste, você pode desativá-la definindo scanForTestClasses para falso.

Agrupamento de Teste

JUnit e TestNG permitem agrupamentos sofisticados de métodos de teste. Para agrupamento, classes e métodos de teste JUnit JUnit 4.8 introduz o conceito de categorias. A tarefa de teste permite a especificação das categorias JUnit que você deseja incluir e excluir.

Você pode usar o seguinte fragmento de código no arquivo build.gradle para agrupar métodos de teste.

test {
   useJUnit {
      includeCategories 'org.gradle.junit.CategoryA'
      excludeCategories 'org.gradle.junit.CategoryB'
   }
}

Incluir e Excluir Testes Particulares

o Test classe tem um include e excludemétodo. Esses métodos podem ser usados ​​para especificar quais testes realmente devem ser executados.

Execute apenas os testes incluídos -

test {
   include '**my.package.name/*'
}

Pular testes excluídos -

test {
   exclude '**my.package.name/*'
}

A amostra build.gradle como mostrado abaixo, ele mostra diferentes opções de configuração.

apply plugin: 'java' // adds 'test' task

test {
   // enable TestNG support (default is JUnit)
   useTestNG()

   // set a system property for the test JVM(s)
   systemProperty 'some.prop', 'value'

   // explicitly include or exclude tests
   include 'org/foo/**'
   exclude 'org/boo/**'

   // show standard out and standard error of the test JVM(s) on the console
   testLogging.showStandardStreams = true

   // set heap size for the test JVM(s)
   minHeapSize = "128m"
   maxHeapSize = "512m"

   // set JVM arguments for the test JVM(s)
   jvmArgs '-XX:MaxPermSize=256m'
   
   // listen to events in the test execution lifecycle
   beforeTest { 
      descriptor → logger.lifecycle("Running test: " + descriptor)
   }

   // listen to standard out and standard error of the test JVM(s)
   onOutput { 
      descriptor, event → logger.lifecycle
         ("Test: " + descriptor + " produced standard out/err: " 
         + event.message )
   }
}

Você pode usar a seguinte sintaxe de comando para executar algumas tarefas de teste.

gradle <someTestTask> --debug-jvm