¿Cómo agrego un nuevo conjunto de orígenes a Gradle?

Question

Quiero agregar pruebas de integración a mi compilación de Gradle (Versión 1.0). Deberían ejecutarse por separado de mis pruebas normales porque requieren que se implemente una aplicación web en localhost (prueban esa aplicación web). Las pruebas deberían poder usar clases definidas en mi fuente principal. ¿Cómo hago que esto suceda?

Answer 1

Esto me tomó un tiempo para averiguarlo y los recursos en línea no eran geniales. Así que quería documentar mi solución.

Este es un simple script de construcción Gradle que tiene una fuente intTest establecer, además de las principales fuente de prueba y conjuntos:

apply plugin: "java" 

sourceSets { 
    // Note that just declaring this sourceset creates two configurations. 
    intTest { 
     java { 
      compileClasspath += main.output 
      runtimeClasspath += main.output 
     } 
    } 
} 

configurations { 
    intTestCompile.extendsFrom testCompile 
    intTestRuntime.extendsFrom testRuntime 
} 

task intTest(type:Test){ 
    description = "Run integration tests (located in src/intTest/...)." 
    testClassesDir = project.sourceSets.intTest.output.classesDir 
    classpath = project.sourceSets.intTest.runtimeClasspath 
} 

Answer 2

Así es como he logrado esto sin usar configurations{ }.

apply plugin: 'java' 

sourceCompatibility = JavaVersion.VERSION_1_6 

sourceSets { 
    integrationTest { 
     java { 
      srcDir 'src/integrationtest/java' 
     } 
     resources { 
      srcDir 'src/integrationtest/resources' 
     } 
     compileClasspath += sourceSets.main.runtimeClasspath 
    } 
} 

task integrationTest(type: Test) { 
    description = "Runs Integration Tests" 
    testClassesDir = sourceSets.integrationTest.output.classesDir 
    classpath += sourceSets.integrationTest.runtimeClasspath 
} 

Probado usando: Gradle 1.4 y Gradle 1,6

Answer 3

Para resumir ambas viejas respuestas (obtener mejores y más viable mínima de ambos mundos):

algunas palabras cálidas en primer lugar:

1. primero, necesitamos definir el conjunto de origen:

    
   sourceSets { 
       integrationTest 
   } 
   

2. siguiente nos expanda el sourceSet de prueba, para ello utilizamos la runtimeClasspath de prueba (que incluye todos los deps de prueba y prueba en sí) como ruta de clases para el sourceSet derivada

    
   sourceSets { 
       integrationTest { 
        compileClasspath += sourceSets.test.runtimeClasspath 
        runtimeClasspath += sourceSets.test.runtimeClasspath // ***) 
       } 
   } 
   

   • *** Nota) de alguna manera esto redeclaración/extender para sourceSets.integrationTest.runtimeClasspath que se necesita, pero debe ser irrelevante, ya que siempre se expande runtimeClasspath output + runtimeSourceSet, no lo entiendo

3. definimos una tarea específica para la realización de pruebas de integración simplemente

    
   task integrationTest(type: Test) { 
   } 
   

4. dicen que el trabajo de prueba que las clases de prueba y rutas de clases deben ser utilizados en lugar de los valores predeterminados de sourceset "prueba"

    
   task integrationTest(type: Test) { 
       testClassesDir = sourceSets.integrationTest.output.classesDir 
       classpath = sourceSets.integrationTest.runtimeClasspath 
   } 
   

5. (opcional) de ejecución auto después prueba

    
   integrationTest.dependsOn test 
   

6. (opcional) auto run con check

    
   check.dependsOn integrationTest 
   

7. (opcional) agrega java, recursos al conjunto de origen para permitir la autodetección y crear estos "parciales" en tu IDE. es decirIntelliJ IDEA creará automáticamente directorios sourceSet Java y recursos para cada conjunto si no existe

    
   sourceSets { 
       integrationTest { 
        java 
        resources 
       } 
   } 
   

tl; dr

apply plugin: 'java' 

// apply the runtimeClasspath from "test" sourceSet to the new one 
// to include any needed assets: test, main, test-dependencies and main-dependencies 
sourceSets { 
    integrationTest { 
     // not necessary but nice for IDEa's 
     java 
     resources 

     compileClasspath += sourceSets.test.runtimeClasspath 
     // somehow this redeclaration is needed, but should be irrelevant 
     // since runtimeClasspath always expands compileClasspath 
     runtimeClasspath += sourceSets.test.runtimeClasspath 
    } 
} 

// define custom test task for running integration tests 
task integrationTest(type: Test) { 
    testClassesDir = sourceSets.integrationTest.output.classesDir 
    classpath = sourceSets.integrationTest.runtimeClasspath 
} 
integrationTest.dependsOn test 

referirse a:

• gradle java chapter 45.7.1. Source set properties
• gradle java chapter 45.7.3. Some source set examples

por desgracia, el código de ejemplo en github.com/gradle/gradle/subprojects/docs/src/samples/java/customizedLayout/build.gradle o …/gradle/…/withIntegrationTests/build.gradle parece no manejar esto o tiene una solución diferente para mí/más complejo/no más claro de todos modos!

Answer 4

El nebula-facet plug-in elimina el texto modelo:

apply plugin: 'nebula.facet' 
facets { 
    integrationTest { 
     parentSourceSet = 'test' 
    } 
} 

Para las pruebas de integración en concreto, incluso this is done for you, aplicar simplemente:

apply plugin: 'nebula.integtest' 

Los Gradle enlaces portal plug-in para cada uno son:

1. nebula.facet
2. nebula.integtest

Answer 5

Esto es lo que funciona para mí a partir de Gradle 4.0.

sourceSets { 
    integrationTest { 
    compileClasspath += sourceSets.test.compileClasspath 
    runtimeClasspath += sourceSets.test.runtimeClasspath 
    } 
} 

task integrationTest(type: Test) { 
    description = "Runs the integration tests." 
    group = 'verification' 
    testClassesDirs = sourceSets.integrationTest.output.classesDirs 
    classpath = sourceSets.integrationTest.runtimeClasspath 
} 

A partir de la versión 4.0, Gradle ahora utiliza directorios de clases separados para cada idioma en un conjunto de origen. Entonces, si su script de construcción usa sourceSets.integrationTest.output.classesDir, verá la siguiente advertencia de desactivación.

Gradle ahora usa directorios de salida separados para cada lenguaje JVM, pero esta compilación presupone un único directorio para todas las clases desde un conjunto de origen. Este comportamiento ha quedado obsoleto y está programado para eliminarse en Gradle 5.0

Para deshacerse de esta advertencia, simplemente cambie a sourceSets.integrationTest.output.classesDirs. Para obtener más información, consulte el Gradle 4.0 release notes.