test - ¿Cómo usar JUnit 5 con Gradle?

jupiter test

Question

Estoy tratando de usar JUnit 5 con Gradle después de haber tenido éxito en la ejecución de una prueba de JUnit 4.

Resultado esperado: La prueba de JUnit 4 dio un buen ''aprobado'' en la salida y un informe html en build/reports/tests .

Resultado real: la prueba JUnit 5 como se muestra a continuación no (...) build succesful nada además de (...) build succesful , aunque sé que la prueba no se ejecuta realmente ya que no se ha pasado / omitido / fallado la salida del registro de prueba, y se pone un fail en el prueba mantiene la construcción exitosa.

La ejecución de la gradle test --info produce la Skipping task '':testClasses'' as it has no actions. entre muchos creo que sobre todo la salida irrelevante. Sorprendentemente, también dice Executing task '':test'' y Generating HTML test report... Finished generating test html results y similares para el xml en build/test-results/test , mientras que el xml no se genera, el html no muestra pruebas ejecutar y no hay errores, y la prueba no se ejecuta.

Lo que también me parece muy interesante, es que la gradle test --debug rinde

[TestEventLogger] Gradle Test Run :test STARTED
[org.gradle.api.internal.tasks.testing.junit.JUnitDetector] test-class-
scan : failed to scan parent class java/lang/Object, could not find the class file
[TestEventLogger]
[TestEventLogger] Gradle Test Run :test PASSED

mientras que mi única prueba contiene

fail("test fails");

que creo que es muy extraño!

Mi archivo de compilación es

apply plugin: ''java''

test {
    dependsOn ''cleanTest'' // run tests every time

}

sourceSets {
    main {
        java {
            srcDirs ''src''
        }
    }
    test {
        java {
            srcDirs ''test''
        }
    }
}

repositories {
    mavenCentral()
}

dependencies {
    // when using this, it worked with a junit 4 test
//    testCompile ''junit:junit:4.10''
    // this should be needed for junit 5 (using M4 is required since IJ 2017.1.2
    testCompile("org.junit.jupiter:junit-jupiter-api:5.0.0-M4")
}

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

Mi prueba es

package mypackage;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class HelloWorldTest {
    @Test
    public void testHelloWorld(){
        assertEquals(2, 1+1, "message");
    }
}

Mi estructura de carpetas es, usando el paquete mypackage ,

java-template-project
--- src
    --- mypackage
        --- HelloWorld.java
--- test
    --- mypackage
        --- HelloWorldTest.java

y en IntelliJ 2017.1.3, que estoy usando, la estructura del módulo se ve así

java-template-project
--- java-template-project_main
    --- src/mypackage
        --- HelloWorld(.java)
--- java-template-project_test
    --- test/mypackage
        --- HelloWorldTest(.java)

Porque Gradle hoy en día quiere la fuente y las pruebas en su propio paquete.

Lo que intenté

Obviamente, esta no es la primera pregunta sobre este tema, todas las preguntas relevantes que encontré son

• Proyecto Gradle ejecutando jUnit 5 pruebas en IntelliJ

  Pero como puede ver, esto es para versiones anteriores de IntelliJ, y ya estoy usando la sintaxis para IJ 2016.3.3 y superior de acuerdo con una de las respuestas, en la línea de dependencia de JUnit, por lo que debería estar bien.

• Actualización de JUnit 4 a JUnit 5 en intellij con gradle

  Los enlaces regresan a la pregunta anterior y los enlaces a este blog de Jetbrains que usa la misma línea que la pregunta anterior. También enlaces a:

• Integre los resultados de las pruebas JUnit 5 con el informe de prueba Intellij. Esta muestra, en la pregunta, también como dependencia

  testRuntime("org.junit.vintage:junit-vintage-engine:5.0.0-M1")

  que se explica en ¿Por qué se separaron JUnit Jupiter y JUnit Vintage cuando ejecuto TestCase en IntelliJ? Bueno, cuando lo ejecuté, la salida mostró que no podía encontrar esta versión, pero según el repositorio de Maven, esta es para JUnit 5:

  testRuntime("org.junit.vintage:junit-vintage-engine:4.12.0-M4")

  Las respuestas allí indican que puede ejecutar las pruebas en IntelliJ ya que las versiones posteriores tienen soporte para JUnit 5. Lo sé, y la prueba se ejecuta bien cuando corro desde IntelliJ. Pero quiero usar Gradle (y Travis, que necesita administración de dependencias).

• ¿Cómo capturar stdout / stderr en el informe de prueba junit 5 gradle?

  Traté de usar

  testCompile("org.junit.platform:junit-platform-gradle-plugin:1.0.0-M3")
  testCompile("org.junit.jupiter:junit-jupiter-engine:5.0.0-M3")

  pero los resultados no cambiaron.

  El proyecto de mi plantilla se encuentra en https://github.com/PHPirates/java-template-project pero esta pregunta debe contener toda la información necesaria.

Answer 1

Nuevo: soporte JUnit 5 en Gradle 4.6

Como se señala en este número de GitHub de Gradle 4.6 en adelante, ¡se admite JUnit 5! Notas de publicación oficiales de 4.6 (en el momento de editar las últimas, pero verifique el enlace a continuación) en docs.gradle.org . La configuración anterior aún funcionará, pero usar esto hace que el archivo de compilación sea mucho más limpio.

Actualizar Gradle

Primero, asegúrese de estar usando la última versión de Gradle, verifique las últimas versiones en sus versiones de GitHub . Si eso es, por ejemplo, 4.6, ejecute en un terminal en la ubicación de su proyecto gradlew wrapper --gradle-version=4.6 o asegúrese de actualizar esta línea en su gradle/wrapper/gradle-wrapper.properties : distributionUrl=https/://services.gradle.org/distributions/gradle-4.6-all.zip .

Cómo utilizar el JUnit 5 incorporado

Luego con los archivos java, la estructura de directorios, etc. de la pregunta que será el archivo build.gradle (usando el nuevo bloque de plugins )

plugins {
    id ''java''
}

repositories {
    mavenCentral()
    mavenLocal()
}

dependencies {
    testImplementation ''org.junit.jupiter:junit-jupiter-api:5.0.3''
    testRuntimeOnly ''org.junit.jupiter:junit-jupiter-engine:5.0.3''
}

// These lines can be removed when you use the default directories src/main/kotlin and src/test/kotlin
sourceSets {
    main.java.srcDirs += ''src''
    main.resources.srcDirs += ''src''
    test.java.srcDirs += ''test''
    test.resources.srcDirs += ''test''
}

// Java target version
sourceCompatibility = 1.8

test {
    // Enable JUnit 5 (Gradle 4.6+).
    useJUnitPlatform()

    // Always run tests, even when nothing changed.
    dependsOn ''cleanTest''

    // Show test results.
    testLogging {
        events "passed", "skipped", "failed"
    }
}

PS Para la versión mínima absoluta, vea la respuesta de Ray .

Answer 2

Debido a la compatibilidad incorporada de github para JUnit 5, programada para Gradle 4.6

Por lo tanto, desde gradle 4.6, su resultado esperado debe ser el mismo que el resultado real.

Resultado esperado : La prueba de JUnit 4 dio un buen ''aprobado'' en la salida y un informe html en build/reports/tests .

UPD:

gradle 4.6-rc-1 se lanzó el 16 de febrero de 2018 y esta versión proporciona el soporte integrado para Junit 5.

Para habilitar el soporte de Junit 5 necesita actualizar el contenedor de Gradle:

gradle wrapper --gradle-version=4.6-rc-1

y agrega solo una línea a build.gradle:

test {
    useJUnitPlatform()
}

Answer 3

Necesita los motores para las dos versiones de JUnit y debe aplicar el complemento gradle de la plataforma JUnit. No veo eso en tu archivo de gradle. Aquí está una compilación de Gradle de trabajo ejecutando tanto JUnit 4 como 5:

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath ("org.junit.platform:junit-platform-gradle-plugin:1.0.0-M4")
    }
}

apply plugin: ''org.junit.platform.gradle.plugin''
...

dependencies {
...
    testCompile("junit:junit:4.12")
    testRuntime("org.junit.vintage:junit-vintage-engine:4.12.0-M4")

    testCompile("org.junit.jupiter:junit-jupiter-api:5.0.0-M4")
    testRuntime("org.junit.jupiter:junit-jupiter-engine:5.0.0-M4")

    // Enable use of the JUnitPlatform Runner within the IDE
    testCompile("org.junit.platform:junit-platform-runner:1.0.0-M4")
}

junitPlatform {
    details ''tree''
}

Ver el formulario de documentación JUnit más información sobre eso.

Answer 4

simplemente agregando a la base de conocimientos, acabo de obtener lo siguiente para trabajar con gradle 4.7:

apply plugin: ''java''
repositories {
    jcenter()
}

dependencies {
    testImplementation ''org.junit.jupiter:junit-jupiter-api:5.1.1''
    testRuntimeOnly ''org.junit.jupiter:junit-jupiter-engine:5.1.1''
}

test {
    useJUnitPlatform()
}