¿Cómo agrego un nuevo conjunto de fuentes a Gradle?

Quiero agregar pruebas de integración a mi compilación de Gradle (Versión 1.0). Deben 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 conjunto de fuentes principal. ¿Cómo hago para que esto suceda?

Me tomó un tiempo darme cuenta y los recursos en línea no eran excelentes. Así que quería documentar mi solución.

Este es un simple script de compilación de Gradle que tiene un conjunto de fuentes intTest además de los conjuntos de fuentes principal y de prueba:

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
}

Así es como lo logré 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 con: Gradle 1.4 y Gradle 1.6

¡Esto se escribió una vez para Gradle 2.x / 3.x en 2016 y está muy desactualizado ! Eche un vistazo a las soluciones documentadas en Gradle 4 y versiones posteriores

Para resumir las dos respuestas anteriores (obtenga la mejor y la mínima viabilidad de ambos mundos):

algunas palabras cálidas primero:

1. primero, necesitamos definir sourceSet:

   sourceSets {
       integrationTest
   }

2. a continuación, expandimos el sourceSetfrom test, por lo tanto usamos el test.runtimeClasspath(que incluye todas las dependencias de testAND test) como classpath para el derivado sourceSet:

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

   • nota ) de alguna manera esta redeclaración / extensión sourceSets.integrationTest.runtimeClasspathes necesaria, pero debería ser irrelevante ya que runtimeClasspathsiempre se expande output + runtimeSourceSet, no la entiendas

3. definimos una tarea dedicada solo para ejecutar pruebas de integración:

   task integrationTest(type: Test) {
   }

4. Configure las integrationTestclases de prueba y el uso de classpaths. Los valores predeterminados del javacomplemento utilizan eltest sourceSet

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

5. (opcional) ejecución automática después de la prueba

   integrationTest.dependsOn test
   

6. (opcional) agregue dependencia de check(para que siempre se ejecute cuando buildo checkse ejecuten)

   tasks.check.dependsOn(tasks.integrationTest)

7. (opcional) agregue java, recursos para sourceSetadmitir la detección automática y cree estos "parciales" en su IDE. es decir, IntelliJ IDEA creará automáticamente sourceSetdirectorios 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
}
tasks.integrationTest.dependsOn(tasks.test)

refiriéndose a:

• gradle java capítulo 45.7.1. Propiedades del conjunto de fuentes
• gradle java capítulo 45.7.3. Algunos ejemplos de conjuntos de fuentes

Desafortunadamente, 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 / más complejo / para mí no hay una solución más clara de todos modos!

El complemento nebula-facet elimina el texto estándar:

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

Para las pruebas de integración específicamente, incluso esto se hace por usted , solo aplique:

apply plugin: 'nebula.integtest'

Los enlaces del portal de complementos de Gradle para cada uno son:

1. nebulosa faceta
2. nebula.integtest

Si estas usando

• Gradle 5.x, eche un vistazo a la Sección de documentación "Prueba de Java> Configuración de pruebas de integración Ejemplo 14 y 15 para obtener más detalles (tanto para Groovy como para Kotlin DSL, o cuál prefiera)
  
  • alt: enlace de documento de Gradle "actual" en 2 , pero podría diferir en el futuro, debería echarle un vistazo si los ejemplos cambian)
• para Gradle 4, eche un vistazo a la versión antigua 3, que se acerca mucho a lo que @Spina publicó en 2012

Para que IntelliJ reconozca el conjunto de fuentes personalizado como raíz de fuentes de prueba:

plugin {
    idea
}

idea {
    module {
        testSourceDirs = testSourceDirs + sourceSets["intTest"].allJava.srcDirs
        testResourceDirs = testResourceDirs + sourceSets["intTest"].resources.srcDirs
    }
}

Esto es lo que me funciona 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 usa directorios de clases separados para cada idioma en un conjunto de fuentes. Entonces, si su script de compilación usa sourceSets.integrationTest.output.classesDir, verá la siguiente advertencia de desaprobación.

Gradle ahora usa directorios de salida separados para cada lenguaje JVM, pero esta compilación asume un solo directorio para todas las clases de un conjunto de fuentes. 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 las notas de la versión de Gradle 4.0 .

Soy nuevo en Gradle y uso Gradle 6.0.1 JUnit 4.12. Esto es lo que se me ocurrió para resolver este problema.

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

dependencies {
    testImplementation 'junit:junit:4.12'
}

sourceSets {
  main {
    java {
       srcDirs = ['src']
    }
  }
  test {
    java {
      srcDirs = ['tests']
    }
  }
}

Observe que se hace referencia a la fuente principal y la fuente de prueba por separado, una debajo mainy otra debajo test.

El testImplementationelemento de abajo dependenciessolo se usa para compilar la fuente en test. Si su código principal en realidad tuviera una dependencia de JUnit, también debería especificar implementationendependencies .

Tuve que especificar el repositories sección para que esto funcione, dudo que sea la mejor / única forma.