Saya memiliki konfigurasi multi-proyek dan saya ingin menggunakan gradle.

Proyek saya seperti ini:

• Proyek A

  • -> src/main/java
  • -> src/test/java

• Proyek B

  • -> src/main/java(tergantung src/main/javapada Proyek A )
  • -> src/test/java(tergantung src/test/javapada Proyek A )

File Project B saya build.gradleseperti ini:

apply plugin: 'java'
dependencies {
  compile project(':ProjectA')
}

Tugas compileJavapekerjaan besar tetapi compileTestJavatidak mengkompilasi file tes dari Project A .

Tidak digunakan lagi - Untuk Gradle 5.6 ke atas gunakan jawaban ini .

Di Proyek B , Anda hanya perlu menambahkan testCompileketergantungan:

dependencies {
  ...
  testCompile project(':A').sourceSets.test.output
}

Diuji dengan Gradle 1.7.

Cara sederhana adalah menambahkan ketergantungan tugas eksplisit di ProjectB:

compileTestJava.dependsOn tasks.getByPath(':ProjectA:testClasses')

Cara sulit (tetapi lebih jelas) adalah membuat konfigurasi artefak tambahan untuk ProjectA:

task myTestsJar(type: Jar) { 
  // pack whatever you need...
}

configurations {
  testArtifacts
}

artifacts {
   testArtifacts myTestsJar
}

dan tambahkan testCompileketergantungan untuk ProjectB

apply plugin: 'java'
dependencies {
  compile project(':ProjectA')
  testCompile project(path: ':ProjectA', configuration: 'testArtifacts')
}

Ini sekarang didukung sebagai fitur kelas satu di Gradle. Modul dengan javaatau java-libraryplugin juga dapat menyertakan sebuah java-test-fixturesplugin yang memaparkan kelas pembantu dan sumber daya untuk dikonsumsi bersama testFixturespembantu. Manfaat dari pendekatan ini terhadap artefak dan pengklasifikasi adalah:

• manajemen ketergantungan yang tepat (implementasi / api)
• pemisahan yang bagus dari kode uji (set sumber terpisah)
• tidak perlu menyaring kelas tes untuk mengekspos hanya utilitas
• dikelola oleh Gradle

Contoh

:modul:one

modul / one / build.gradle

plugins {
  id "java-library" // or "java"
  id "java-test-fixtures"
}

modul / one / src / testFixtures / java / com / example / Helper.java

package com.example;
public class Helper {}

:modul:other

modul / other / build.gradle

plugins {
  id "java" // or "java-library"
}
dependencies {
  testImplementation(testFixtures(project(":modul:one")))
}

modul / other / src / test / java / com / example / other / SomeTest.java

package com.example.other;
import com.example.Helper;
public class SomeTest {
  @Test void f() {
    new Helper(); // used from :modul:one's testFixtures
  }
}

Bacaan lebih lanjut

Untuk info lebih lanjut, lihat dokumentasi:
https://docs.gradle.org/current/userguide/java_testing.html#sec:java_test_fixtures

Itu ditambahkan dalam 5.6:
https://docs.gradle.org/5.6/release-notes.html#test-fixtures-for-java-projects

Saya sendiri telah menemukan masalah ini baru-baru ini, dan manusia adalah masalah sulit untuk menemukan jawaban.

Kesalahan yang Anda buat adalah berpikir bahwa suatu proyek harus mengekspor elemen pengujiannya dengan cara yang sama seperti ia mengekspor artefak dan dependensi utamanya.

Apa yang saya lebih sukses secara pribadi adalah membuat proyek baru di Gradle. Dalam contoh Anda, saya akan menyebutkannya

Project A_Test -> src / main / java

Saya akan memasukkan ke dalam src / main / java file yang saat ini Anda miliki di Project A / src / test / java. Buat setiap dependensi testCompile dari Proyek Anda, kompilasi dependensi dari Project A_Test.

Kemudian buat Project A_Test sebuah dependensi testCompile dari Project B.

Itu tidak logis ketika Anda datang dari sudut pandang penulis kedua proyek, tapi saya pikir itu masuk akal ketika Anda berpikir tentang proyek-proyek seperti junit dan scalatest (dan lain-lain. Meskipun kerangka kerja tersebut terkait pengujian, mereka tidak dianggap sebagai bagian dari target "test" dalam kerangka kerja mereka sendiri - mereka menghasilkan artefak utama yang kebetulan digunakan oleh proyek lain dalam konfigurasi pengujian mereka. Anda hanya ingin mengikuti pola yang sama.

Mencoba melakukan jawaban lain yang tercantum di sini tidak bekerja untuk saya secara pribadi (menggunakan Gradle 1.9), tetapi saya telah menemukan bahwa pola yang saya jelaskan di sini adalah solusi yang lebih bersih.

Saya tahu ini adalah pertanyaan lama tetapi saya hanya memiliki masalah yang sama dan menghabiskan waktu mencari tahu apa yang sedang terjadi. Saya menggunakan Gradle 1.9. Semua perubahan harus dalam ProjectBbuild.gradle

Untuk menggunakan kelas uji dari ProjectA dalam tes ProjectB:

testCompile files(project(':ProjectA').sourceSets.test.output.classesDir)

Untuk memastikan bahwa sourceSetsproperti tersedia untuk ProjectA:

evaluationDependsOn(':ProjectA')

Untuk memastikan kelas tes dari ProjectA benar-benar ada, ketika Anda mengkompilasi ProjectB:

compileTestJava.dependsOn tasks.getByPath(':ProjectA:testClasses')

Solusi testJar baru (didukung dependensi trnsitif) tersedia sebagai plugin gradle:

https://github.com/hauner/gradle-plugins/tree/master/jartest

https://plugins.gradle.org/plugin/com.github.hauner.jarTest/1.0

Dari dokumentasi

Jika Anda memiliki multi-proyek gradle build, Anda dapat menguji dependensi antar sub-proyek (yang mungkin merupakan petunjuk bahwa proyek Anda tidak terstruktur dengan baik).

Sebagai contoh, asumsikan sebuah proyek di mana sub proyek Proyek B bergantung pada Proyek A dan B tidak hanya memiliki ketergantungan kompilasi pada A tetapi juga ketergantungan uji. Untuk mengkompilasi dan menjalankan tes B kita membutuhkan beberapa kelas penolong tes dari A.

Secara default gradle tidak membuat artefak jar dari output build proyek.

Plugin ini menambahkan konfigurasi testArchives (berdasarkan testCompile) dan tugas jarTest untuk membuat jar dari set sumber tes (dengan tes classifier ditambahkan ke nama jar). Kita kemudian dapat bergantung pada B pada konfigurasi testArchives A (yang juga akan mencakup dependensi transitif A).

Dalam A kita akan menambahkan plugin ke build.gradle:

apply plugin: 'com.github.hauner.jarTest'

Di B kami mereferensikan konfigurasi testArchives seperti ini:

dependencies {
    ...
    testCompile project (path: ':ProjectA', configuration: 'testArchives') 
}

Silakan baca pembaruan di bawah.

Masalah serupa yang dijelaskan oleh JustACluelessNewbie terjadi di IntelliJ IDEA. Masalahnya adalah bahwa ketergantungan testCompile project(':core').sourceSets.test.outputsebenarnya berarti: "bergantung pada kelas yang dihasilkan oleh tugas pembangunan gradle". Jadi, jika Anda membuka proyek bersih di mana kelas tidak dihasilkan namun IDEA tidak akan mengenalinya dan melaporkan kesalahan.

Untuk memperbaiki masalah ini, Anda harus menambahkan ketergantungan pada file sumber tes di samping ketergantungan pada kelas yang dikompilasi.

// First dependency is for IDEA
testCompileOnly files { project(':core').sourceSets.test.java.srcDirs }
// Second is for Gradle
testCompile project(':core').sourceSets.test.output

Anda dapat mengamati dependensi yang dikenali oleh IDEA dalam Pengaturan Modul -> Ketergantungan (lingkup pengujian) .

Btw. ini bukan solusi yang bagus sehingga refactoring patut dipertimbangkan. Gradle sendiri memiliki sub-proyek khusus yang hanya berisi kelas-kelas dukungan tes. Lihat https://docs.gradle.org/current/userguide/test_kit.html

Perbarui 2016-06-05 Lebih Banyak Saya berpikir tentang solusi yang diusulkan kurang saya suka. Ada beberapa masalah dengan itu:

1. Itu menciptakan dua dependensi di IDEA. Satu poin untuk menguji sumber lain ke kelas yang dikompilasi. Dan sangat penting agar keteraturan ini diakui oleh IDEA. Anda dapat bermain dengannya dengan mengubah urutan ketergantungan pada pengaturan Modul -> tab Dependensi.
2. Dengan mendeklarasikan dependensi ini Anda tidak perlu mencemari struktur dependensi.

Jadi apa solusi yang lebih baik? Menurut pendapat saya itu menciptakan set sumber kustom baru dan menempatkan kelas bersama ke dalamnya. Sebenarnya penulis proyek Gradle melakukannya dengan membuat set sumber testFixtures.

Untuk melakukannya Anda hanya perlu:

1. Buat kumpulan sumber dan tambahkan konfigurasi yang diperlukan. Periksa plugin skrip ini yang digunakan dalam proyek Gradle: https://github.com/gradle/gradle/blob/v4.0.0/gradle/testFixtures.gradle

2. Menyatakan ketergantungan yang tepat dalam proyek tergantung:

   dependencies {
       testCompile project(path: ':module-with-shared-classes', configuration: 'testFixturesUsageCompile')
   }
   

3. Impor proyek Gradle ke IDEA dan gunakan opsi "buat modul terpisah per set sumber" saat mengimpor.

Solusi Fesler tidak berhasil untuk saya, ketika saya mencobanya untuk membangun proyek android (gradle 2.2.0). Jadi saya harus referensi kelas yang diperlukan secara manual:

android {
    sourceSets {
        androidTest {
            java.srcDir project(':A').file("src/androidTest/java")
        }
        test {
            java.srcDir project(':A').file("src/test/java")
        }
    }
}

Saya sangat terlambat ke pesta (sekarang Gradle v4.4) tetapi untuk siapa pun yang menemukan ini:

Asumsi:

~/allProjects
|
|-/ProjectA/module-a/src/test/java
|
|-/ProjectB/module-b/src/test/java

Pergi ke build.gradle proyek B (yang membutuhkan beberapa kelas uji dari A) dan tambahkan yang berikut ini:

sourceSets {
    String sharedTestDir = "${projectDir}"+'/module-b/src/test/java'
    test {
        java.srcDir sharedTestDir
    }
}

atau (dengan asumsi proyek Anda bernama "ProjectB")

sourceSets {
    String sharedTestDir = project(':ProjectB').file("module-b/src/test/java")
    test {
        java.srcDir sharedTestDir
    }
}

Voila!

Jika Anda memiliki dependensi tiruan yang perlu Anda bagikan di antara tes, Anda dapat membuat proyek baru projectA-mockdan kemudian menambahkannya sebagai dependensi tes ke ProjectAdan ProjectB:

dependencies {
  testCompile project(':projectA-mock')
}

Ini adalah solusi yang jelas untuk dependensi berbagi pura-pura, tapi jika Anda perlu untuk menjalankan tes dari ProjectAdalam ProjectBpenggunaan solusi lain.

Jika ingin digunakan dependensi artifak untuk memiliki:

• Kelas sumber ProyekB bergantung pada kelas sumber Proyek A.
• Kelas uji ProjectB bergantung pada kelas uji Project A.

maka bagian dependensi ProjectB di build.gradle akan terlihat seperti ini:

dependencies {

  compile("com.example:projecta:1.0.0")

  testCompile("com.example:projecta:1.0.0:tests")

}

Agar ini berfungsi, ProjectA perlu membangun a toples- uji dan memasukkannya ke dalam artefak yang dihasilkannya.

Build.gradle ProjectA harus berisi konfigurasi seperti ini:

task testsJar(type: Jar, dependsOn: testClasses) {
    classifier = 'tests'
    from sourceSets.test.output
}

configurations {
    tests
}

artifacts {
    tests testsJar
    archives testsJar
}

jar.finalizedBy(testsJar)

Ketika artefak ProjectA dipublikasikan ke artifactory Anda, mereka akan menyertakan- pengujian toples- .

The testCompile pada bagian dependensi ProjectB akan membawa kelas di -tests jar.

Jika Anda ingin menyertakan sumber dan kelas uji ProjectAFlat di ProjectB untuk tujuan pengembangan maka bagian dependensi di build.gradle ProjectB akan terlihat seperti ini:

dependencies {

  compile project(':projecta')

  testCompile project(path: ':projecta', configuration: 'tests')

}

Beberapa jawaban lain menyebabkan kesalahan satu atau lain cara - Gradle tidak mendeteksi kelas uji dari proyek lain atau proyek Eclipse memiliki dependensi yang tidak valid ketika diimpor. Jika ada yang memiliki masalah yang sama, saya sarankan pergi dengan:

testCompile project(':core')
testCompile files(project(':core').sourceSets.test.output.classesDir)

Baris pertama memaksa Eclipse untuk menghubungkan proyek lain sebagai ketergantungan, sehingga semua sumber disertakan dan terkini. Yang kedua memungkinkan Gradle untuk benar-benar melihat sumber, sementara tidak menyebabkan kesalahan ketergantungan yang tidak valid seperti yang testCompile project(':core').sourceSets.test.outputdilakukan.

Di sini jika Anda menggunakan Kotlin DSL , Anda harus membuat tugas Anda seperti itu menurut dokumentasi Gradle .

Seperti beberapa jawaban sebelumnya, Anda perlu membuat konfigurasi khusus di dalam proyek yang akan membagikan kelas tesnya, sehingga Anda tidak mencampur tes dan kelas utama.

Langkah sederhana

1. Dalam proyek A Anda perlu menambahkan build.gradle.kts:

configurations {
    create("test")
}

tasks.register<Jar>("testArchive") {
    archiveBaseName.set("ProjectA-test")
    from(project.the<SourceSetContainer>()["test"].output)
}

artifacts {
    add("test", tasks["testArchive"])
}

2. Kemudian dalam proyek B Anda di dependensi, Anda perlu menambahkan build.gradle.kts:

dependencies {
    implementation(project(":ProjectA"))
    testImplementation(project(":ProjectA", "test"))
}

dalam proyek B:

dependencies {
  testCompile project(':projectA').sourceSets.test.output
}

Tampaknya bekerja di 1.7-rc-2