Gradle: Cómo mostrar Resultados de la prueba de la consola en tiempo real?

StackOverflow https://stackoverflow.com/questions/3963708

  •  09-10-2019
  •  | 
  •  

Pregunta

Me gustaría ver los resultados de pruebas (system.out / err, los mensajes de registro de componentes están probando) ya que corren en la misma consola corro: 

gradle test

Y no espere hasta que se realizan pruebas para ver los informes de las pruebas (que sólo se generan cuando se hayan completado las pruebas, así que no puedo "tail-f" nada mientras se ejecutan las pruebas)

¿Fue útil?

Solución

Gradle podía correr con el nivel de registro INFO en la línea de comandos. Se va a mostrar el resultado de cada prueba mientras se están ejecutando. Lo malo es que obtendrá mucho más salida para otras tareas también. 

gradle test -i

Otros consejos

Esta es mi versión de lujo:

resultado de la prueba de fantasía 

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

Puede agregar un cierre maravilloso dentro de su archivo build.gradle que hace el registro para usted: 

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

En la consola, entonces se lee como sigue: 

: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

Desde la versión 1.1 admite Gradle mucho más opciones de registro de salida de prueba . Con esas opciones a la mano se puede lograr un resultado similar con la siguiente configuración: 

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

stefanglase contestado:

añadir el siguiente código a su build.gradle (desde la versión 1.1) de multa trabaja para la salida en pasado , omitido y fallidos pruebas. 

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

Lo que quiero decir, además, (descubrí que esto es un problema para empezar) es que el comando gradle test ejecuta la prueba sólo una vez por el cambio .

Así que si lo está ejecutando en el segunda vez no habrá salida de los resultados de pruebas . También puede ver esto en la salida del edificio: Gradle luego dice UP-A-FECHA en los exámenes. Así que no es ejecutado una enésima vez.

Smart Gradle!

Si desea forzar los casos de prueba para funcionar, el uso gradle cleanTest test.

Esto es un poco fuera de tema, pero espero que le ayudará a algunos novatos.

editar

sparc_spread se indica en los comentarios:

Si desea forzar Gradle a Ejecutar siempre sometido a nuevas pruebas (que no siempre pueden ser una buena idea) se pueden agregar a outputs.upToDateWhen {false} testLogging { [...] }. Seguir leyendo aquí .

Paz.

exención de responsabilidad:. Yo soy el programador de la prueba Gradle Logger Plugin

Usted simplemente puede usar el Gradle prueba Logger Plugin para imprimir registros en hermosas la consola. El plug-in utiliza los valores iniciales adecuados para satisfacer la mayoría de los usuarios con poca o ninguna configuración, pero también ofrece una serie de temas y opciones de configuración para todos los gustos.

Nota: Prueba Gradle Logger Plugin v1.4 + ahora es compatible con la ejecución de pruebas en paralelo también. Sólo tiene que utilizar un adecuada tema .

Ejemplos

Tema Estándar tema estándar

Mocha Theme Mocha tema

Uso 

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

Asegúrese de que siempre obtiene el última versión de Gradle central .

Configuración

Usted no necesita ninguna configuración en absoluto. Sin embargo, el plugin ofrece algunas opciones. Esto puede hacerse como sigue (los valores por defecto se muestra): 

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
}

Espero que disfrute con su uso.

Añadir a esta build.gradle a Gradle parada por la ingestión de stdout y stderr. 

test {
    testLogging.showStandardStreams = true
}

Está documentado aquí

tarea 'prueba' no funciona para plugin de Android, Android plug-in para utilizar lo siguiente: 

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

Vea el siguiente: https://stackoverflow.com/a/31665341/3521637

Como seguimiento a gran respuesta de Shubham me gusta sugerir el uso de enumeración en lugar de los valores de cadenas . Por favor, eche un vistazo a la documentación de la clase 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
    }
}

Mi versión favorita minimalista basado en la respuesta Shubham Chaudhary. introducir descripción de la imagen aquí

Ponga esto en el archivo build.gradle: 

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

En Gradle usando el plugin de Android: 

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

A continuación, la salida será:

Ejecutora testConversionMinutes de prueba [org.example.app.test.DurationTest] con resultado: ÉXITO

gran respuesta de Shubham y JJD uso de enumeración en lugar de cadena 

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

A raíz de respuesta de Benjamin Muschko (19 de marzo de 2011), se puede usar la bandera -i junto con grep , para filtrar los 1000s de líneas no deseadas. Ejemplos:

Filtro Fuerte - Sólo mostrar el nombre de cada unidad de prueba y el resultado, y el estado general de su construcción. no se muestran errores de configuración o excepciones. 

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

Filtro suave - Muestra el nombre de cada unidad de prueba y el resultado, así como la configuración de errores / excepciones. Pero también incluirá algo de información irrelevante: 

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

Filtro suave, la sintaxis alternativa: (búsqueda fichas se dividen en cadenas individuales) 

./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:"

Explicación de cómo funciona: La salida del primer comando, ./gradlew test -i, se canaliza a una segunda grep de comandos, que filtrará a cabo muchas líneas no deseadas sobre la base de una expresión regular. "-E" permite el modo de expresión regular, y los medios "|" "o". Un nombre de unidad de prueba y el resultado se permite visualizar utilizando " > ", y el estado general se permite con "BUILD". En el filtro suave, los medios bandera "-v" "no contiene" y "^" medios "inicio desconectado". Por lo que excluye los todas las líneas que comienzan con "Ejecutar" o comienzan con "Crear", etc.

Ejemplo para Android pruebas de unidad de instrumentación, con 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:"

Ejemplo para la cobertura de prueba de unidad Jacoco, con Gradle 4,10: 

./gradlew createDebugCoverageReport --continue -i | grep -E -v "^Executing |^Creating |^Parsing |^Using |^Merging |^Download |^title=Compiling|^AAPT|^future=|^task=|:app:|V/InstrumentationResultParser:"
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top