Comment ajouter un nouvel ensemble de sources à Gradle?

Je souhaite ajouter des tests d'intégration à ma version Gradle (version 1.0). Ils doivent s'exécuter séparément de mes tests normaux car ils nécessitent le déploiement d'une application Web sur localhost (ils testent cette application Web). Les tests devraient pouvoir utiliser les classes définies dans mon ensemble de sources principal. Comment y parvenir?

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

Il s'agit d'un simple script de construction gradle qui a un ensemble de sources intTest en plus des ensembles de sources principal et de 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
}

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

Cela a été écrit une fois pour Gradle 2.x / 3.x en 2016 et est loin d'être dépassé !! Veuillez jeter un œil aux 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 d'abord:

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

   sourceSets {
       integrationTest
   }

2. Ensuite, nous développons le sourceSetfrom test, donc nous utilisons le test.runtimeClasspath(qui inclut toutes les dépendances de testAND testlui - même) comme chemin de classe pour le dérivé sourceSet:

   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.runtimeClasspathest nécessaire, mais ne devrait pas être pertinente car se runtimeClasspathdéveloppe toujours output + runtimeSourceSet, ne l'obtenez pas

3. nous définissons une tâche dédiée pour simplement exécuter des tests d'intégration:

   task integrationTest(type: Test) {
   }

4. Configurez les integrationTestclasses de test et les chemins de classe utilisés. Les valeurs par défaut du javaplugin utilisent letest sourceSet

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

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

   integrationTest.dependsOn test
   

6. (facultatif) ajouter une dépendance de check(donc il s'exécute toujours quand buildou checkest exécuté)

   tasks.check.dependsOn(tasks.integrationTest)

7. (facultatif) ajoutez java, des ressources au sourceSetpour prendre en charge la détection automatique et créez ces "partiels" dans votre IDE. ie IntelliJ IDEA créera automatiquement des sourceSetrépertoires java et des 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 à:

• gradle java chapitre 45.7.1. Propriétés de l'ensemble de sources
• gradle java chapitre 45.7.3. Quelques exemples d'ensemble de sources

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

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 cela est fait pour vous , il suffit d'appliquer:

apply plugin: 'nebula.integtest'

Les liens du portail du plugin Gradle pour chacun sont:

1. nebula.facet
2. nebula.integtest

Si vous utilisez

• Gradle 5.x, consultez la section Documentation "Test de Java> Configuration des tests d'intégration Exemples 14 et 15 pour plus de détails (pour Groovy et Kotlin DSL, que vous préférez)
  
  • alt: lien de la documentation Gradle "actuel" à 2 , mais pourrait différer à l'avenir, vous devriez voir si les exemples changent)
• pour Gradle 4, jetez un œil à l'ancienne version 3 qui est proche de ce que @Spina a publié en 2012

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

plugin {
    idea
}

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

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 séparés pour chaque langue d'un ensemble source. Donc, si votre script de construction utilise sourceSets.integrationTest.output.classesDir, vous verrez l'avertissement de désapprobation suivant.

Gradle utilise désormais des répertoires de sortie distincts pour chaque langage JVM, mais cette version suppose un répertoire unique 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 simplement à sourceSets.integrationTest.output.classesDirs. Pour plus d'informations, consultez les notes de publication de Gradle 4.0 .

Je suis nouveau sur Gradle, en utilisant Gradle 6.0.1 JUnit 4.12. Voici ce que j'ai proposé pour résoudre ce problème.

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

dependencies {
    testImplementation 'junit:junit:4.12'
}

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

Notez que la source principale et la source de test sont référencées séparément, une sous mainet une sous test.

L' testImplementationélément ci-dessous dependenciesest uniquement utilisé pour compiler la source dans test. Si votre code principal avait en fait une dépendance sur JUnit, vous devez également spécifier implementationsousdependencies .

J'ai dû spécifier la repositoriessection pour que cela fonctionne, je doute que ce soit le meilleur / le seul moyen.