web-dev-qa-db-fra.com

Comment ajouter un nouveau jeu de sources à Gradle?

Je souhaite ajouter des tests d'intégration à ma version Gradle (version 1.0). Ils doivent être exécutés séparément de mes tests habituels, car ils nécessitent le déploiement d’une application Web sur localhost (ils testent cette application Web). Les tests doivent pouvoir utiliser les classes définies dans mon ensemble source principal. Comment puis-je y arriver?

javagradlebuildintegration-testingsource-sets
75
Spina

Cela m'a pris du temps à comprendre et les ressources en ligne n'étaient pas géniales. Je voulais donc documenter ma solution.

Il s'agit d'un script de construction de dégradé simple qui possède un ensemble source intTest en plus des ensembles source et test:

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
}
93
Spina

Voici comment j'ai réalisé cela sans utiliser 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
}

Testé avec: Gradle 1.4 et Gradle 1.6

28
Mike Rylander

C'était une fois écrit pour Gradle 2.x/3.x en 2016 et est bien dépassé !! Veuillez consulter les solutions documentées dans Gradle 4 et plus

Pour résumer les deux anciennes réponses (obtenir le meilleur et le minimum viable des deux mondes):

quelques mots chaleureux en premier:

  1. tout d'abord, nous devons définir la sourceSet:

    sourceSets {
    integrationTest
}

  2. ensuite, nous développons la sourceSet à partir de test. Nous utilisons donc le test.runtimeClasspath (qui inclut toutes les dépendances de test AND test lui-même) comme chemin de classe pour la sourceSet dérivée:

    sourceSets {
    integrationTest {
        compileClasspath += sourceSets.test.runtimeClasspath
        runtimeClasspath += sourceSets.test.runtimeClasspath // ***)
    }
}
    • note) d'une manière ou d'une autre, cette redéclaration/extension pour sourceSets.integrationTest.runtimeClasspath est nécessaire, mais ne doit pas être pertinente car runtimeClasspath développe toujours output + runtimeSourceSet, ne l'obtenez pas.

  3. nous définissons une tâche dédiée à l'exécution de tests d'intégration:

    task integrationTest(type: Test) {
}

  4. Configurez les classes de test integrationTest et les chemins de classes utilisés. Les valeurs par défaut du plugin Java utilisent le testsourceSet

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

  5. (facultatif) exécution automatique après test _ 

     integrationTest.dependsOn test

  6. (facultatif) ajouter une dépendance à partir de check (ainsi, il est toujours exécuté lorsque build ou check sont exécutés)

    tasks.check.dependsOn(tasks.integrationTest)

  7. (facultatif) ajoutez Java, des ressources à la sourceSet pour prendre en charge la détection automatique et créer ces "partiels" dans votre IDE. i.e. IntelliJ IDEA créera automatiquement les répertoires sourceSet Java et les ressources pour chaque ensemble s'il n'existe pas:

    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)

se référant à:

Malheureusement, l'exemple de code figurant sur github.com/gradle/gradle/subprojects/docs/src/samples/Java/customizedLayout/build.gradle ou …/gradle /…/withIntegrationTests/build.gradle semble ne pas gérer cela ou a un différent/plus complexe/pour moi aucune solution plus claire de toute façon! 

15
childno͡.de

Le plugin nebula-facet élimine le passe-partout:

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

Pour les tests d'intégration en particulier, même ceci est fait pour vous , appliquez simplement:

apply plugin: 'nebula.integtest'

Les liens de portail du plugin Gradle pour chacun sont:

  1. nébuleuse.facet
  2. nebula.integtest
6
jkschneider

Voici ce qui fonctionne pour moi à 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
}

Depuis la version 4.0, Gradle utilise désormais des répertoires de classes distincts pour chaque langue d'un ensemble source. Ainsi, si votre script de génération utilise sourceSets.integrationTest.output.classesDir, l'avertissement de dépréciation suivant s'affiche.

Gradle utilise maintenant des répertoires de sortie distincts pour chaque langage JVM, mais cette construction suppose un seul répertoire pour toutes les classes d'un ensemble source. Ce comportement est obsolète et doit être supprimé dans Gradle 5.0.

Pour vous débarrasser de cet avertissement, passez plutôt à sourceSets.integrationTest.output.classesDirs. Pour plus d'informations, reportez-vous aux notes de version de Gradle 4.0 .

1
Ryan Sobol

Si vous utilisez 

Pour qu'IntelliJ reconnaisse un ensemble de sources personnalisé en tant que racine de sources de test:

plugin {
    idea
}

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