Como executar o teste Gradle quando todos os testes estão atualizados?

Eu tenho meu script de notas configurado. Quando executo a compilação Gradle, tudo está funcionando e ele executa os testes do jUnit.

Depois disso, quando executo o teste Gradle, recebo o seguinte:

C:\Users\..\..\Project>gradle test
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:compileTestJava UP-TO-DATE
:processTestResources UP-TO-DATE
:testClasses UP-TO-DATE
:test UP-TO-DATE

Quando eu executo gradle clean, a construção do Gradle funciona, é claro ... Eu quero poder redefinir apenas os testes, não o projeto inteiro: como devo fazer isso?

Uma opção seria usar o --rerun-taskssinalizador na linha de comando . Isso executaria novamente toda a tarefa de teste e todas as tarefas das quais depende.

Se você estiver interessado apenas em executar novamente os testes, outra opção seria fazer com que o gradle limpe os resultados dos testes antes de executá-los. Isso pode ser feito usando a cleanTesttarefa.

Alguns antecedentes - o plug-in Java define tarefas limpas para cada uma das outras tarefas. De acordo com a documentação :

cleanTaskName - Exclui os arquivos criados pela tarefa especificada. O cleanJar excluirá o arquivo JAR criado pela tarefa jar e o cleanTest excluirá os resultados do teste criados pela tarefa de teste.

Portanto, tudo o que você precisa para executar novamente seus testes é também executar a cleanTesttarefa, ou seja:
gradle cleanTest test

Outra opção seria adicionar o seguinte em seu build.gradle:

test.outputs.upToDateWhen {false}

gradle test --rerun-tasks

Especifica que qualquer otimização de tarefa é ignorada.

Fonte: https://gradle.org/docs/current/userguide/gradle_command_line.html

Esse foi recentemente o tópico na postagem do blog de Gradle. Pare de executar novamente seus testes . O autor mostra um exemplo usando outputs.upToDateWhen { false }e explica por que está errado:

Na verdade, isso não força as reprises

O que o autor deste trecho provavelmente queria dizer é "Sempre execute novamente meus testes". Mas não é isso que esse trecho faz. Ele marcará apenas a tarefa desatualizada, forçando Gradle a recriar a saída. Mas eis o seguinte: se o cache de compilação estiver ativado, Gradle não precisará executar a tarefa para recriar a saída. Ele encontrará uma entrada no cache e descompacta o resultado no diretório de saída do teste.

O mesmo vale para este trecho:

test.dependsOn cleanTest

Gradle descompactará os resultados do teste do cache de compilação após a limpeza da saída, para que nada seja executado novamente. Em resumo, esses trechos estão criando um no-op muito caro.

Se agora você está pensando em "Ok, eu vou desativar o cache também", deixe-me dizer por que você não deveria.

Em seguida, o autor continua explicando por que executar novamente alguns testes é uma perda de tempo:

A grande maioria dos seus testes deve ser determinística, ou seja, dadas as mesmas entradas, eles devem produzir o mesmo resultado.

Nos poucos casos em que você deseja executar novamente os testes nos quais o código não foi alterado, você deve modelá-los como uma entrada. Aqui estão os dois exemplos da postagem do blog que mostram a adição de uma entrada para que a tarefa a use durante suas verificações atualizadas.

task randomizedTest(type: Test) {
  systemProperty "random.testing.seed", new Random().nextInt()
}

task systemIntegrationTest(type: Test) {
  inputs.property "integration.date", LocalDate.now()
}

Eu recomendo a leitura de todo o post do blog.

Aqui está uma solução usando o arquivo "build.gradle", caso você não queira modificar sua linha de comando:

test {
    dependsOn 'cleanTest'
    //Your previous task details (if any)
}

E aqui está a saída. Observe 2 alterações em relação à saída anterior:

1) Uma nova tarefa 'cleanTest' aparece na saída.

2) 'teste' é sempre limpo (ou seja, nunca 'ATUALIZADO'), por isso é executado sempre:

$ gradle build
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:findMainClass
:jar
:bootRepackage
:assemble
:cleanTest
:compileTestJava UP-TO-DATE
:processTestResources UP-TO-DATE
:testClasses UP-TO-DATE
:test
:check
:build

--rerun-tasks funciona, mas é ineficiente, pois executa novamente todas as tarefas.

cleanTest por si só pode não ser suficiente devido ao cache de compilação.

portanto, a melhor maneira de fazer isso é:

./gradlew --no-build-cache cleanTest test

Além disso, ter que adicionar --rerun-tasksé realmente redundante. Isso nunca acontece. Crie um --no-rerun-taskse torne-o --rerun-taskspadrão quandocleanTask

TL; DR

test.dependsOn cleanTest

Eu acho que essa é uma pergunta válida, uma vez que é possível em Gradle executar este comando test, e o que acontece é que nada acontece!

Mas eu questionaria a necessidade de fazer isso, como Jolta disse em seu comentário: se nenhum código foi alterado, por que você precisa testar novamente? Se você tiver dúvidas sobre a entrada de terceiros, eu diria que você precisa atender a isso no código do aplicativo. Se você tem medo de que seu código seja "esquisito", ou seja, capaz de passar em todos os testes pela primeira vez, mas não uma segunda (ou centésima vez), você não precisa pensar por que tem essas dúvidas e resolvê-las?

Pessoalmente, acho que isso é uma falha de design (muito menor) em Gradle: se tudo estiver completamente atualizado, em vez de se tornar "CONSTRUÍDO COM SUCESSO", deve dizer "SEM MUDANÇA DESDE O ÚLTIMO CONSTRUÇÃO COM SUCESSO: NADA FAZER".