Come eseguire il test Gradle quando tutti i test sono AGGIORNATI?

Ho impostato la mia sceneggiatura di livello. Quando eseguo la build Gradle, tutto funziona ed esegue i test jUnit.

Dopodiché quando eseguo il test Gradle ottengo quanto segue:

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 eseguo gradle clean, quindi Gradle build funziona, ovviamente ... Voglio essere in grado di ripristinare solo i test, non di costruire l'intero progetto: come devo fare?

Un'opzione sarebbe usare il --rerun-tasksflag nella riga di comando . Ciò eseguirà nuovamente tutte le attività di test e tutte le attività da cui dipende.

Se sei interessato solo a rieseguire i test, un'altra opzione sarebbe quella di rendere il gradle clean i risultati dei test prima di eseguire i test. Questo può essere fatto usando l' cleanTestattività.

Alcuni retroscena: il plug-in Java definisce attività pulite per ciascuna delle altre attività. Secondo la documentazione :

cleanTaskName : elimina i file creati dall'attività specificata. cleanJar eliminerà il file JAR creato dall'attività jar e cleanTest eliminerà i risultati del test creati dall'attività test.

Pertanto, tutto ciò che serve per rieseguire i test è eseguire anche l' cleanTestattività, ovvero:
gradle cleanTest test

Un'altra opzione sarebbe quella di aggiungere quanto segue nel tuo build.gradle:

test.outputs.upToDateWhen {false}

gradle test --rerun-tasks

Specifica che qualsiasi ottimizzazione dell'attività viene ignorata.

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

Recentemente questo è stato l'argomento sul post sul blog di Gradle Smetti di ripetere i tuoi test . L' autore mostra un esempio usando outputs.upToDateWhen { false }e spiega perché è sbagliato:

Questo in realtà non forza le repliche

Ciò che l'autore di questo frammento probabilmente ha voluto dire è "Rieseguire sempre i miei test". Questo non è ciò che fa questo frammento. Contrassegna solo l'attività non aggiornata, costringendo Gradle a ricreare l'output. Ma ecco il punto, se la cache di build è abilitata, Gradle non ha bisogno di eseguire l'attività per ricreare l'output. Troverà una voce nella cache e decomprimerà il risultato nella directory di output del test.

Lo stesso vale per questo frammento:

test.dependsOn cleanTest

Gradle decomprimerà i risultati del test dalla cache di build dopo che l'output è stato pulito, quindi non verrà eseguito nuovamente nulla. In breve, questi frammenti stanno creando una no-op molto costosa.

Se ora stai pensando "Ok, anch'io disattiverò la cache", lascia che ti dica perché non dovresti.

Quindi, l'autore continua spiegando perché rieseguire alcuni test è una perdita di tempo:

La stragrande maggioranza dei test dovrebbe essere deterministica, ovvero, dati gli stessi input, dovrebbero produrre lo stesso risultato.

Nei pochi casi in cui si desidera rieseguire i test in cui il codice non è stato modificato, è necessario modellarli come input. Ecco entrambi gli esempi del post sul blog che mostrano l'aggiunta di un input in modo che l'attività lo utilizzi durante i suoi controlli aggiornati.

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

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

Consiglio di leggere l'intero post del blog.

Ecco una soluzione che utilizza il file "build.gradle", nel caso in cui non si desideri modificare la riga di comando:

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

Ed ecco l'output. Notare 2 modifiche rispetto all'output precedente:

1) Nell'output viene visualizzata una nuova attività "cleanTest".

2) 'test' viene sempre pulito (cioè mai 'UP-TO-DATE') quindi viene eseguito ogni volta:

$ 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 funziona, ma è inefficiente in quanto esegue nuovamente tutte le attività.

cleanTest di per sé potrebbe non essere sufficiente a causa della compilazione della cache.

quindi, il modo migliore per raggiungere questo obiettivo è:

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

Inoltre, dover aggiungere --rerun-tasksè davvero ridondante. Non succede mai Crea un --no-rerun-taskse rendi --rerun-taskspredefinito quandocleanTask

TL; DR

test.dependsOn cleanTest

Penso che questa sia una domanda valida dato che in Gradle è possibile eseguire questo comando test e ciò che accade è che non succede nulla!

Ma metterei in dubbio la necessità di farlo, come ha detto Jolta nel suo commento: se nessun codice è cambiato, perché è necessario ripetere il test? Se hai dubbi sugli input di terze parti, direi che devi provvedere a questo nel tuo codice dell'app. Se temi che il tuo codice possa essere "instabile", ovvero in grado di superare tutti i test la prima volta ma non una seconda (o la centesima volta), non hai bisogno di pensare al motivo per cui hai questi dubbi e di affrontarli?

Personalmente penso che questo sia un errore di progettazione (molto minore) in Gradle: se tutto è completamente aggiornato, piuttosto che andare "BUILD SUCCESSFUL" dovrebbe dire "NESSUN CAMBIAMENTO DALL'ULTIMO SUCCESSFIL BUILD: NULLA FATTO".