Jak dodać nowy zestaw źródeł do Gradle?

Chcę dodać testy integracji do mojej kompilacji Gradle (wersja 1.0). Powinny działać niezależnie od moich normalnych testów, ponieważ wymagają wdrożenia aplikacji internetowej na serwerze lokalnym (testują tę aplikację internetową). Testy powinny móc korzystać z klas zdefiniowanych w moim głównym zestawie źródłowym. Jak to zrobić?

Zajęło mi to trochę czasu, a zasoby internetowe nie były świetne. Dlatego chciałem udokumentować moje rozwiązanie.

To jest prosty skrypt budujący gradle, który oprócz głównego i testowego zestawu źródłowego ma ustawione źródło intTest:

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
}

Oto jak to osiągnąłem bez użycia 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
}

Przetestowano przy użyciu: Gradle 1.4 i Gradle 1.6

Zostało to kiedyś napisane dla Gradle 2.x / 3.x w 2016 roku i jest bardzo przestarzałe !! Proszę spojrzeć na udokumentowane rozwiązania w Gradle 4 i nowszych

Podsumowując obie stare odpowiedzi (uzyskaj najlepszą i minimalną wykonalność obu światów):

najpierw kilka ciepłych słów:

1. najpierw musimy zdefiniować sourceSet:

   sourceSets {
       integrationTest
   }

2. następnie rozwijamy sourceSetfrom test, dlatego używamy test.runtimeClasspath(który zawiera wszystkie zależności od samego testAND test) jako ścieżki klas dla wyprowadzonych sourceSet:

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

   • uwaga ) w jakiś sposób ta ponowna deklaracja / rozszerzenie dla sourceSets.integrationTest.runtimeClasspathjest potrzebna, ale powinna być nieistotna, ponieważ runtimeClasspathzawsze się rozwija output + runtimeSourceSet, nie otrzymuj tego

3. definiujemy dedykowane zadanie do przeprowadzenia samych testów integracyjnych:

   task integrationTest(type: Test) {
   }

4. Skonfiguruj integrationTestklasy testowe i ścieżki klas. Wartości domyślne z javawtyczki używają rozszerzeniatest sourceSet

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

5. (opcjonalnie) automatyczne uruchamianie po teście

   integracjaTest.dependsOn test
   

6. (opcjonalnie) dodaj zależność od check(więc zawsze działa, gdy buildlub checksą wykonywane)

   tasks.check.dependsOn(tasks.integrationTest)

7. (opcjonalnie) dodaj java, zasoby do sourceSetobsługi automatycznego wykrywania i utwórz te „częściowe” w swoim IDE. tzn. IntelliJ IDEA automatycznie utworzy sourceSetkatalogi java i zasoby dla każdego zestawu, jeśli nie istnieje:

   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)

odwołujący się do:

• gradle java rozdział 45.7.1. Właściwości zestawu źródłowego
• gradle java rozdział 45.7.3. Niektóre przykłady zestawów źródłowych

Niestety, przykładowy kod na github.com/gradle/gradle/subprojects/docs/src/samples/java/customizedLayout/build.gradle lub … / gradle /… / withIntegrationTests / build.gradle wydaje się nie obsługiwać tego lub ma inny / bardziej złożone / dla mnie i tak nie ma jaśniejszego rozwiązania!

Mgławica-aspekt wtyczki eliminuje boilerplate:

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

W szczególności w przypadku testów integracyjnych, nawet jeśli jest to zrobione za Ciebie , po prostu zastosuj:

apply plugin: 'nebula.integtest'

Linki do portalu wtyczek Gradle dla każdego z nich to:

1. nebula.facet
2. nebula.integtest

Jeśli używasz

• Gradle 5.x, zajrzyj do sekcji Dokumentacja „Testowanie Java> Konfigurowanie testów integracyjnych Przykład 14 i 15, aby poznać szczegóły (zarówno dla Groovy, jak i Kotlin DSL, którykolwiek wolisz)
  
  • alt: „bieżący” link do dokumentu Gradle na 2 , ale może zostać odroczony w przyszłości, powinieneś sprawdzić, czy przykłady się zmienią)
• w przypadku Gradle 4 spójrz na starożytną wersję 3, która jest zbliżona do tego, co @Spina opublikował w 2012 roku

Aby IntelliJ rozpoznał niestandardowy zestaw źródeł jako root źródeł testowych:

plugin {
    idea
}

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

Oto, co działa dla mnie od wersji 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
}

Począwszy od wersji 4.0, Gradle używa teraz oddzielnych katalogów klas dla każdego języka w zestawie źródłowym. Jeśli więc Twój skrypt kompilacji używa sourceSets.integrationTest.output.classesDir, zobaczysz następujące ostrzeżenie o wycofaniu.

Gradle używa teraz osobnych katalogów wyjściowych dla każdego języka JVM, ale ta kompilacja zakłada jeden katalog dla wszystkich klas ze zbioru źródłowego. To zachowanie zostało wycofane i jest zaplanowane do usunięcia w Gradle 5.0

Aby pozbyć się tego ostrzeżenia, po prostu przełącz się na sourceSets.integrationTest.output.classesDirs. Aby uzyskać więcej informacji, zobacz informacje o wersji Gradle 4.0 .

Jestem nowy w Gradle, używam Gradle 6.0.1 JUnit 4.12. Oto, co wymyśliłem, aby rozwiązać ten problem.

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

dependencies {
    testImplementation 'junit:junit:4.12'
}

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

Zauważ, że główne źródło i źródło testowe są przywoływane osobno, jedno poniżej maini jedno poniżejtest .

testImplementationPod poz dependenciessłuży tylko za zebranie źródło w test. Jeśli twój główny kod faktycznie miał zależność od JUnit, możesz również określić implementationponiżejdependencies .

Musiałem określić repositoriessekcję, aby to zadziałało, wątpię, czy jest to najlepszy / jedyny sposób.