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

Question

Je voudrais voir les résultats des tests (system.out / err, les messages du journal à partir de composants testés) comme ils courent dans la même console je lance:

gradle test

Et ne pas attendre jusqu'à ce que des tests sont effectués pour examiner les rapports de test (qui ne sont générés lorsque les tests sont terminés, donc je ne peux pas « tail -f » quoi que ce soit alors que les tests sont en cours d'exécution)

Answer 1

Vous pourriez exécuter Gradle avec le niveau de journalisation INFO sur la ligne de commande. Il va vous montrer le résultat de chaque test pendant leur exécution. Le seul inconvénient est que vous obtiendrez beaucoup plus de sortie pour d'autres tâches aussi.

gradle test -i

Answer 2

Voici ma version de fantaisie:

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))
            }
        }
    }
}

Answer 3

Vous pouvez ajouter une fermeture Groovy dans votre fichier build.gradle qui fait l'enregistrement pour vous:

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

Sur votre console, il se lit alors comme ceci:

: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 prend en charge beaucoup Gradle plus d'options pour connecter la sortie de test . Avec ces options à portée de main, vous pouvez obtenir une sortie similaire avec la configuration suivante:

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

Answer 4

stefanglase répondu:

ajoutant le code suivant à votre build.gradle (depuis la version 1.1) fonctionne très bien pour la sortie sur passé , sautée et a échoué des tests .

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

Ce que je veux dire en plus (j'ai découvert ce problème pour commencer) est que la commande gradle test exécute le test une seule fois par le changement .

Donc, si vous l'exécutez deuxième fois il n'y aura pas de sortie sur les résultats des tests . Vous pouvez également voir dans la sortie du bâtiment: gradle dit alors UP-TO-DATE sur les tests. Donc, ce ne est pas exécuté un temps n-ième.

Smart gradle!

Si vous voulez forcer les cas de test à exécuter, l'utilisation gradle cleanTest test.

est un peu hors sujet, mais j'espère que cela aidera certains débutants.

modifier

sparc_spread indiqué dans les commentaires:

Si vous voulez forcer gradle toujours exécuter des tests frais (qui pourrait ne pas toujours être une bonne idée) que vous pouvez ajouter à outputs.upToDateWhen {false} testLogging { [...] }. Continuer la lecture .

Paix.

Answer 5

Disclaimer:. Je suis le développeur de l'enregistreur de test Gradle Plugin

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

  

Remarque: Gradle test Logger Plugin v1.4 + prend désormais en charge l'exécution de test en parallèle aussi. Il suffit d'utiliser un thème approprié .

Exemples

thème standard

thème Mocha

Utilisation

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

Assurez-vous que vous obtenez toujours le dernière version de Gradle centrale.

Configuration

Vous ne nécessite aucune configuration du tout. Cependant, le plug-in offre quelques options. Cela peut se faire comme suit (les valeurs par défaut indiqué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.

Answer 6

Ajoutez ceci à l'arrêt build.gradle gradle d'avaler stdout et stderr.

test {
    testLogging.showStandardStreams = true
}

Il est documenté

Answer 7

tâche 'test' ne fonctionne pas pour le plugin Android, pour Android plug-in utiliser les éléments suivants:

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

Voir les éléments suivants: https://stackoverflow.com/a/31665341/3521637

Answer 8

Pour donner suite à grande réponse de Shubham J'aime suggère d'utiliser ENUM au lieu des valeurs de chaînes . S'il vous plaît jeter un oeil à la documentation de 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
    }
}

Answer 9

Ma version préférée minimalistic fonction de la réponse Shubham Chaudhary.

Mettre cela 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)")
    }
}

Answer 10

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, la sortie sera:

  

testConversionMinutes de test d'exécution [org.example.app.test.DurationTest] avec résultat: SUCCES

Answer 11

Fusion de grande réponse de Shubham et JJD utilisation ENUM au lieu de chaîne

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))
           }
       }
   }
}

Answer 12

Suite à réponse de Benjamin Muschko (19 Mars 2011), vous pouvez utiliser le drapeau -i ainsi que grep , pour filtrer les 1000s de lignes non désirées. Exemples:

Filtre forte - afficher uniquement le nom de chaque test unitaire et le résultat et l'état général de construction. les erreurs de configuration ou des exceptions ne sont pas affichées.

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

---

Filtre doux - Afficher le nom de chaque test unitaire et le résultat, ainsi que les erreurs configuration / exceptions. Mais il inclura aussi quelques 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: (recherche jetons 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 la façon dont cela fonctionne: La sortie de la première commande, ./gradlew test -i, est canalisé vers une deuxième commande grep, qui filtre les nombreuses lignes non désirées à partir d'une expression régulière. "-E" permet le mode d'expression régulière, et des moyens de "|" « ou ». est autorisé Un nom de test unitaire et le résultat à afficher à l'aide " > " et l'état général est autorisé à "BUILD". Dans le filtre doux, le moyen de drapeau de "-v" « ne contenant pas de » moyens et "^" « début de la ligne ». Donc, il supprime toutes les lignes qui commencent par « exécution » ou commençant par « Création », etc.

---

Exemple pour les tests unitaires d'instrumentation Applications, avec gradle 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 de test unitaire Jacoco, avec gradle 4.10:

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