web-dev-qa-db-fra.com

Gradle: Comment afficher les résultats de test dans la console en temps réel?

Je souhaite voir les résultats des tests (system.out/err, enregistrer les messages des composants testés) pendant leur exécution dans la même console que celle que je lance:

gradle test

Et n'attendez pas que les tests soient terminés pour consulter les rapports de test (ceux-ci ne sont générés que lorsque les tests sont terminés, je ne peux donc rien en queue pendant l'exécution des tests)

testingconsolegradle
197
tolitius

Vous pouvez exécuter Gradle avec le niveau de journalisation INFO en ligne de commande. Il vous montrera le résultat de chaque test en cours d'exécution. L'inconvénient est que vous obtiendrez beaucoup plus de résultats pour d'autres tâches également.

gradle test -i
145
Benjamin Muschko

Voici ma version de fantaisie:

fancy test result

import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.tasks.testing.logging.TestLogEvent

tasks.withType(Test) {
    testLogging {
        // set options for log level LIFECYCLE
        events TestLogEvent.FAILED,
               TestLogEvent.PASSED,
               TestLogEvent.SKIPPED,
               TestLogEvent.STANDARD_OUT
        exceptionFormat TestExceptionFormat.FULL
        showExceptions true
        showCauses true
        showStackTraces true

        // set options for log level DEBUG and INFO
        debug {
            events TestLogEvent.STARTED,
                   TestLogEvent.FAILED,
                   TestLogEvent.PASSED,
                   TestLogEvent.SKIPPED,
                   TestLogEvent.STANDARD_ERROR,
                   TestLogEvent.STANDARD_OUT
            exceptionFormat TestExceptionFormat.FULL
        }
        info.events = debug.events
        info.exceptionFormat = debug.exceptionFormat

        afterSuite { desc, result ->
            if (!desc.parent) { // will match the outermost suite
                def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)"
                def startItem = '|  ', endItem = '  |'
                def repeatLength = startItem.length() + output.length() + endItem.length()
                println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength))
            }
        }
    }
}
142
Shubham Chaudhary

Vous pouvez ajouter une fermeture Groovy dans votre fichier build.gradle qui effectue la journalisation à votre place:

test {
    afterTest { desc, result -> 
        logger.quiet "Executing test ${desc.name} [${desc.className}] with result: ${result.resultType}"
    }
}

Sur votre console, cela se lit comme suit:

:compileJava UP-TO-DATE
:compileGroovy
:processResources
:classes
:jar
:assemble
:compileTestJava
:compileTestGroovy
:processTestResources
:testClasses
:test
Executing test maturesShouldBeCharged11DollarsForDefaultMovie [movietickets.MovieTicketsTests] with result: SUCCESS
Executing test studentsShouldBeCharged8DollarsForDefaultMovie [movietickets.MovieTicketsTests] with result: SUCCESS
Executing test seniorsShouldBeCharged6DollarsForDefaultMovie [movietickets.MovieTicketsTests] with result: SUCCESS
Executing test childrenShouldBeCharged5DollarsAnd50CentForDefaultMovie [movietickets.MovieTicketsTests] with result: SUCCESS
:check
:build

Depuis la version 1.1, Gradle supporte beaucoup plus d’options pour enregistrer les résultats des tests . Avec ces options, vous pouvez obtenir une sortie similaire avec la configuration suivante:

test {
    testLogging {
        events "passed", "skipped", "failed"
    }
}
141
stefanglase

Comme stefanglase a répondu:

l'ajout du code suivant à votre build.gradle (depuis la version 1.1) fonctionne correctement pour une sortie sur , passé , ignoré et a échoué tests.

test {
    testLogging {
        events "passed", "skipped", "failed", "standardOut", "standardError"
    }
}

Ce que je veux dire en plus (j'ai découvert que c'était un problème pour les débutants), c'est que la commande gradle test n'exécute le test qu'une fois par changement .

Donc, si vous l'exécutez une seconde fois , les résultats du test ne seront pas affichés . Vous pouvez également le voir dans la sortie du bâtiment: gradle indique ensuite UP-TO-DATE lors des tests. Donc, ce n'est pas exécuté une nième fois.

Gradé intelligent!

Si vous souhaitez forcer l'exécution des scénarios de test, utilisez gradle cleanTest test.

Ceci est légèrement hors sujet, mais j'espère que cela aidera certains débutants.

modifier

Comme sparc_spread a déclaré dans les commentaires:

Si vous voulez forcer gradle à toujours exécuter de nouveaux tests (ce qui peut ne pas toujours être une bonne idée), vous pouvez ajouter outputs.upToDateWhen {false} à testLogging { [...] }. Continuer la lecture ici .

Paix.

100
Langusten Gustel

Avertissement: Je suis le développeur du plug-in Gradle Test Logger.

Vous pouvez simplement utiliser = Gradle Test Logger Plugin pour imprimer de superbes journaux sur la console. Le plugin utilise des valeurs par défaut sensibles pour satisfaire la plupart des utilisateurs avec peu ou pas de configuration, mais offre également un certain nombre de thèmes et d’options de configuration qui conviennent à tout le monde.

Remarque: Gradle Test Logger Plugin v1.4 + prend désormais également en charge l'exécution de tests en parallèle. Utilisez simplement un thème approprié .

Exemples

Standard Theme Thème standard

Mocha Theme thème Moka

Usage

plugins {
    id 'com.adarshr.test-logger' version '<version>'
}

Assurez-vous de toujours avoir le dernière version de Gradle Central .

Configuration

Vous n'avez besoin d'aucune configuration. Cependant, le plugin offre quelques options. Cela peut être fait comme suit (valeurs par défaut affichées):

testlogger {
    // pick a theme - mocha, standard, plain, mocha-parallel, standard-parallel or plain-parallel
    theme 'standard'

    // set to false to disable detailed failure logs
    showExceptions true

    // set to false to hide stack traces
    showStackTraces true

    // set to true to remove any filtering applied to stack traces
    showFullStackTraces false

    // set to false to hide exception causes
    showCauses true

    // set threshold in milliseconds to highlight slow tests
    slowThreshold 2000

    // displays a breakdown of passes, failures and skips along with total duration
    showSummary true

    // set to true to see simple class names
    showSimpleNames false

    // set to false to hide passed tests
    showPassed true

    // set to false to hide skipped tests
    showSkipped true

    // set to false to hide failed tests
    showFailed true

    // enable to see standard out and error streams inline with the test results
    showStandardStreams false

    // set to false to hide passed standard out and error streams
    showPassedStandardStreams true

    // set to false to hide skipped standard out and error streams
    showSkippedStandardStreams true

    // set to false to hide failed standard out and error streams
    showFailedStandardStreams true
}

J'espère que vous apprécierez l'utiliser.

68
adarshr

Ajoutez ceci à build.gradle pour empêcher Gradle d’avaler les sorties standard et secondaire.

test {
    testLogging.showStandardStreams = true
}

C'est documenté ici .

45
Darwin

La tâche 'test' ne fonctionne pas pour le plug-in Android. Pour Android, le plug-in utilise les éléments suivants:

// Test Logging
tasks.withType(Test) {
    testLogging {
        events "started", "passed", "skipped", "failed"
    }
}

Voir ce qui suit: https://stackoverflow.com/a/31665341/3521637

35
user3521637

En guise de suivi de excellente réponse de Shubham , j’aime suggérer d’utiliser des valeurs enum au lieu de des chaînes . Veuillez consulter documentation de la classe TestLogging .

import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.tasks.testing.logging.TestLogEvent

tasks.withType(Test) {
    testLogging {
        events TestLogEvent.FAILED,
               TestLogEvent.PASSED,
               TestLogEvent.SKIPPED,
               TestLogEvent.STANDARD_ERROR,
               TestLogEvent.STANDARD_OUT
        exceptionFormat TestExceptionFormat.FULL
        showCauses true
        showExceptions true
        showStackTraces true
    }
}
17
JJD

Ma version minimaliste préférée basée sur la réponse de Shubham Chaudhary. enter image description here

Mettez ceci dans le fichier build.gradle:

test {
    afterSuite { desc, result ->
    if (!desc.parent)
        println("${result.resultType} " +
            "(${result.testCount} tests, " +
            "${result.successfulTestCount} successes, " +
            "${result.failedTestCount} failures, " +
            "${result.skippedTestCount} skipped)")
    }
}
11
Andrzej Rehmann

Dans Gradle en utilisant le plugin Android:

gradle.projectsEvaluated {
    tasks.withType(Test) { task ->
        task.afterTest { desc, result ->
            println "Executing test ${desc.name} [${desc.className}] with result: ${result.resultType}"
        }
    }
}

Ensuite, le résultat sera:

Exécution du test testConversionMinutes [org.example.app.test.DurationTest] avec le résultat: SUCCESS

7
radeklos

Fusion de excellente réponse de Shubham et JJD utilise enum au lieu de string

tasks.withType(Test) {
   testLogging {
       // set options for log level LIFECYCLE
       events TestLogEvent.PASSED,
            TestLogEvent.SKIPPED, TestLogEvent.FAILED, TestLogEvent.STANDARD_OUT
       showExceptions true
       exceptionFormat TestExceptionFormat.FULL
       showCauses true
       showStackTraces true

    // set options for log level DEBUG and INFO
       debug {
        events TestLogEvent.STARTED, TestLogEvent.PASSED, TestLogEvent.SKIPPED, TestLogEvent.FAILED, TestLogEvent.STANDARD_OUT, TestLogEvent.STANDARD_ERROR
        exceptionFormat TestExceptionFormat.FULL
       }
       info.events = debug.events
       info.exceptionFormat = debug.exceptionFormat

       afterSuite { desc, result ->
           if (!desc.parent) { // will match the outermost suite
               def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)"
               def startItem = '|  ', endItem = '  |'
               def repeatLength = startItem.length() + output.length() + endItem.length()
               println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength))
           }
       }
   }
}
3
odemolliens

Après réponse de Benjamin Muschko (19 mars 2011), vous pouvez utiliser le drapeau -i avec grep , pour filtrer des milliers de lignes indésirables. Exemples:

Filtre puissant - N'affichez que le nom et le résultat du test unitaire, ainsi que l'état de construction global. Les erreurs d'installation ou les exceptions ne sont pas affichées.

./gradlew test -i | grep -E " > |BUILD"

Filtre progressif - Affiche le nom et le résultat du test de chaque unité, ainsi que les erreurs/exceptions de configuration. Mais cela inclura aussi des informations non pertinentes:

./gradlew test -i | grep -E -v "^Executing |^Creating |^Parsing |^Using |^Merging |^Download |^title=Compiling|^AAPT|^future=|^task=|:app:|V/InstrumentationResultParser:"

Filtre souple, syntaxe alternative: (les jetons de recherche sont divisés en chaînes individuelles)

./gradlew test -i | grep -v -e "^Executing " -e "^Creating " -e "^Parsing " -e "^Using " -e "^Merging " -e "^Download " -e "^title=Compiling" -e "^AAPT" -e "^future=" -e "^task=" -e ":app:" -e "V/InstrumentationResultParser:"

Explication de son fonctionnement: La sortie de la première commande, ./gradlew test -i, est dirigée vers une seconde commande grep, qui filtrera de nombreuses lignes indésirables en fonction d'une expression régulière. "-E" active le mode d'expression régulière et "|" signifie "ou". Le nom et le résultat du test unitaire sont autorisés à s'afficher avec " > ", et l'état général est autorisé avec "BUILD". Dans le filtre souple, l'indicateur "-v" signifie "ne contient pas" et "^" signifie "début de ligne". Donc, il supprime toutes les lignes commençant par "Executing" ou "Creating", etc.

Exemple pour Android tests unitaires d'instrumentation, avec la gradation 5.1: 

./gradlew connectedDebugAndroidTest --continue -i | grep -v -e \
"^Transforming " -e "^Skipping " -e "^Cache " -e "^Performance " -e "^Creating " -e \
"^Parsing " -e "^file " -e "ddms: " -e ":app:" -e "V/InstrumentationResultParser:"

Exemple de couverture d'un test unitaire Jacoco, avec la note 4.10: 

./gradlew createDebugCoverageReport --continue -i | grep -E -v "^Executing |^Creating |^Parsing |^Using |^Merging |^Download |^title=Compiling|^AAPT|^future=|^task=|:app:|V/InstrumentationResultParser:"
2
Mr-IDE