testing - serp - test seo tags

Gradle: ¿Cómo mostrar los resultados de la prueba en la consola en tiempo real?

Question

Me gustaría ver los resultados de las pruebas (system.out / err, mensajes de registro de los componentes que se prueban), ya que se ejecutan en la misma consola que ejecuto:

gradle test

Y no espere hasta que se realicen las pruebas para ver los informes de prueba (que solo se generan cuando se completan las pruebas, por lo que no puedo "ajustar" nada mientras se ejecutan las pruebas)

Answer 1

Agregue esto a build.gradle para evitar que gradle trague stdout y stderr.

test {
    testLogging.showStandardStreams = true
}

Está documentado here .

Answer 2

Aquí está mi versión elegante:

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

Como Stefanglase respondió:

agregar el siguiente código a su build.gradle (desde la versión 1.1) funciona bien para la salida en pruebas pasadas , omitidas y fallidas .

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

Lo que quiero decir adicionalmente (descubrí que esto es un problema para los principiantes) es que el gradle test ejecuta la prueba solo una vez por cambio .

Entonces, si lo está ejecutando la segunda vez, no habrá salida en los resultados de la prueba . También puede ver esto en la salida del edificio: gradle luego dice UP-TO-DATE en las pruebas. Entonces no se ejecuta en enésima vez.

¡Gradle inteligente!

Si desea forzar la ejecución de los casos de prueba, use la gradle cleanTest test .

Esto está un poco fuera de tema, pero espero que ayude a algunos novatos.

editar

Como sparc_spread declaró en los comentarios:

Si desea obligar a Gradle a ejecutar siempre nuevas pruebas (lo que puede no ser siempre una buena idea), puede agregar outputs.upToDateWhen {false} a testLogging { [...] } . Continúa leyendo here .

Paz.

Answer 4

Como seguimiento de la gran respuesta de Shubham, me gusta sugerir el uso de valores enum en lugar 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
    }
}

Answer 5

En Gradle usando el complemento de Android:

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

Entonces la salida será:

Ejecutando la prueba testConversionMinutes [org.example.app.test.DurationTest] con el resultado: SUCCESS

Answer 6

La fusión de la gran respuesta de Shubham y JJD usan enum 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))
           }
       }
   }
}

Answer 7

La tarea de ''prueba'' no funciona para el complemento de Android, para el complemento de Android utiliza lo siguiente:

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

Vea lo siguiente: https://.com/a/31665341/3521637

Answer 8

Mi versión minimalista favorita basada en la respuesta de Shubham Chaudhary.

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

Answer 9

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

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

En su consola, entonces se lee así:

: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, Gradle admite muchas más opciones para registrar la salida de prueba . Con esas opciones a mano, puede lograr un resultado similar con la siguiente configuración:

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

Answer 10

Puede ejecutar Gradle con el nivel de registro INFO en la línea de comando. Le mostrará el resultado de cada prueba mientras se están ejecutando. Lo malo es que obtendrá mucho más rendimiento para otras tareas también.

gradle test -i

Answer 11

Descargo de responsabilidad: soy el desarrollador del complemento Gradle Test Logger.

Puede usar el Plugin de Gradle Test Logger para imprimir hermosos registros en la consola.

Uso

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

Asegúrese de obtener siempre la última versión de Gradle Central .

Configuración

No necesitas ninguna configuración en absoluto. Sin embargo, el complemento ofrece algunas opciones. Esto se puede hacer de la siguiente manera (se muestran los valores predeterminados):

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

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

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

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

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

Espero que disfrutes de usarlo.