У меня есть многопроектная конфигурация, и я хочу использовать gradle.

Мои проекты такие:

• Проект А

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

• Проект Б

  • -> src/main/java(зависит src/main/javaот проекта A )
  • -> src/test/java(зависит src/test/javaот проекта A )

Файл моего проекта B build.gradle выглядит так:

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

Задача compileJavaработы большой , но compileTestJavaне компилировать тестовый файл из проекта A .

Устаревший - для Gradle 5.6 и выше используйте этот ответ .

В проекте B вам просто нужно добавить testCompileзависимость:

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

Протестировано с Gradle 1.7.

Простой способ - добавить явную зависимость задачи в ProjectB:

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

Сложный (но более понятный) способ - создать дополнительную конфигурацию артефактов для ProjectA:

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

configurations {
  testArtifacts
}

artifacts {
   testArtifacts myTestsJar
}

и добавьте testCompileзависимость для ProjectB

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

Теперь это поддерживается как первоклассная функция в Gradle. Модули с плагинами javaили java-libraryмогут также включать в себя java-test-fixturesплагин, который предоставляет вспомогательные классы и ресурсы, которые будут использоваться testFixturesпомощником. Преимущество этого подхода против артефактов и классификаторов:

• правильное управление зависимостями (реализация / API)
• хорошее отделение от тестового кода (отдельный исходный набор)
• не нужно отфильтровывать тестовые классы, чтобы выставлять только утилиты
• поддерживается Gradle

пример

:modul:one

Modul / один / build.gradle

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

Modul / один / SRC / testFixtures / Java / COM / пример / Helper.java

package com.example;
public class Helper {}

:modul:other

Modul / другие / build.gradle

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

Modul / другой / SRC / тест / Java / COM / пример / другой / SomeTest.java

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

дальнейшее чтение

Для получения дополнительной информации см. Документацию:
https://docs.gradle.org/current/userguide/java_testing.html#sec:java_test_fixtures

Он был добавлен в 5.6:
https://docs.gradle.org/5.6/release-notes.html#test-fixtures-for-java-projects

Я недавно столкнулся с этой проблемой, и человек это трудные вопросы, чтобы найти ответы.

Вы делаете ошибку, думая, что проект должен экспортировать свои тестовые элементы так же, как он экспортирует свои основные артефакты и зависимости.

То, с чем я лично добился гораздо большего успеха, - это создание нового проекта в Gradle. В вашем примере я бы назвал это

Проект A_Test -> src / main / java

Я бы поместил в src / main / java файлы, которые у вас есть в Project A / src / test / java. Сделайте любые зависимости testCompile вашего Project A зависимости компиляции Project A_Test.

Затем сделайте Project A_Test зависимостью testCompile проекта B.

Это не логично, когда вы подходите к этому с точки зрения автора обоих проектов, но я думаю, что это имеет смысл, когда вы думаете о таких проектах, как junit и scalatest (и другие. Даже если эти фреймворки связаны с тестированием, они не считаются частью «тестовых» целей в их собственных средах - они создают основные артефакты, которые другие проекты используют в своей тестовой конфигурации. Вы просто хотите следовать той же схеме.

Попытка сделать другие ответы, перечисленные здесь, не сработала лично для меня (используя Gradle 1.9), но я обнаружил, что шаблон, который я здесь описываю, в любом случае является более чистым решением.

Я знаю, что это старый вопрос, но у меня была та же проблема, и я потратил некоторое время на выяснение того, что происходит. Я использую Gradle 1.9. Все изменения должны быть в ProjectB'sbuild.gradle

Чтобы использовать тестовые классы из ProjectA в тестах ProjectB:

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

Чтобы убедиться, что sourceSetsсвойство доступно для ProjectA:

evaluationDependsOn(':ProjectA')

Чтобы убедиться, что тестовые классы из ProjectA действительно присутствуют при компиляции ProjectB:

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

Новое решение на базе testJar (поддерживается trnsitive зависимость), доступное как плагин gradle:

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

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

Из документации

Если у вас многопроектная сборка Gradle, у вас могут быть тестовые зависимости между подпроектами (что, вероятно, является подсказкой о том, что ваши проекты плохо структурированы).

Например, предположим, что проект, в котором подпроект Project B зависит от Project A и B, имеет не только зависимость компиляции от A, но также и тестовую зависимость. Для компиляции и запуска тестов B нам понадобятся несколько вспомогательных классов для тестирования из A.

По умолчанию Gradle не создает JAR-артефакт из результатов тестовой сборки проекта.

Этот плагин добавляет конфигурацию testArchives (на основе testCompile) и задачу jarTest для создания jar из набора тестовых источников (с добавлением теста классификатора к имени jar). Затем мы можем полагаться в B на конфигурацию testArchives для A (которая также будет включать транзитивные зависимости A).

В A мы добавим плагин для build.gradle:

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

В B мы ссылаемся на конфигурацию testArchives следующим образом:

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

Пожалуйста, прочтите обновление ниже.

Подобные проблемы, описанные JustACluelessNewbie, возникают в IntelliJ IDEA. Проблема в том, что зависимость на testCompile project(':core').sourceSets.test.outputсамом деле означает: «зависеть от классов, сгенерированных задачей сборки gradle». Поэтому, если вы откроете чистый проект, где классы еще не созданы, IDEA не распознает их и сообщит об ошибке.

Чтобы решить эту проблему, вы должны добавить зависимость от тестовых исходных файлов рядом с зависимостью от скомпилированных классов.

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

Вы можете наблюдать зависимости, распознаваемые IDEA, в Настройках модуля -> Зависимости (область тестирования) .

Btw. Это не очень хорошее решение, поэтому стоит подумать о рефакторинге. Сам Gradle имеет специальный подпроект, содержащий только классы поддержки тестирования. См. Https://docs.gradle.org/current/userguide/test_kit.html.

Обновление 2016-06-05 Подробнее Я думаю о предлагаемом решении меньше, мне нравится. Есть несколько проблем с этим:

1. Это создает две зависимости в IDEA. Один указывает на тестирование источников, другой на скомпилированные классы. И очень важно, в каком порядке IDEA признает эти зависимости. Вы можете поиграть с ним, изменив порядок зависимостей в Настройках модуля -> вкладка Зависимости.
2. Объявляя эти зависимости, вы излишне загрязняете структуру зависимостей.

Так какое же решение лучше? На мой взгляд, это создание нового пользовательского набора исходных кодов и добавление в него общих классов. На самом деле авторы проекта Gradle сделали это, создав исходный набор testFixtures.

Для этого вам просто нужно:

1. Создайте исходный набор и добавьте необходимые конфигурации. Проверьте этот плагин сценария, используемый в проекте Gradle: https://github.com/gradle/gradle/blob/v4.0.0/gradle/testFixtures.gradle

2. Объявите правильную зависимость в зависимом проекте:

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

3. Импортируйте проект Gradle в IDEA и используйте опцию «создать отдельный модуль для исходного набора» при импорте.

Решение Феслера не сработало для меня, когда я попытался построить проект для Android (версия 2.2.0). Поэтому мне пришлось ссылаться на необходимые классы вручную:

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

Я так опоздал на вечеринку (теперь это Gradle v4.4), но для всех, кто найдет это:

Предполагая, что:

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

Перейдите к build.gradle проекта B (который нуждается в нескольких тестовых классах из A) и добавьте следующее:

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

или (при условии, что ваш проект называется «ProjectB»)

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

Вуаля!

Если у вас есть фиктивные зависимости, которые вам нужно разделить между тестами, вы можете создать новый проект, projectA-mockа затем добавить его как тестовую зависимость ProjectAи ProjectB:

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

Это понятно решение зависимостей доли ложных, но если вам нужно запустить тесты из ProjectAвProjectB использовании другого решения.

Если вы хотите использовать зависимости артефактов, чтобы:

• Исходные классы ProjectB зависят от исходных классов Project A
• Тестовые классы ProjectB зависят от тестовых классов Project A

тогда раздел зависимостей ProjectB в build.gradle должен выглядеть примерно так:

dependencies {

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

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

}

Для того, чтобы это работало, ProjectA необходимо создать банку -tests и включить ее в артефакты, которые он создает.

Файл build.gradle в ProjectA должен содержать следующую конфигурацию:

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

configurations {
    tests
}

artifacts {
    tests testsJar
    archives testsJar
}

jar.finalizedBy(testsJar)

Когда артефакты Projecta публикуются на ваш Artifactory они будут включать в себя - тесты банку .

TestCompile в зависимости разделе ProjectB принесет в классах в - тестах баночки.

Если вы хотите включить исходный и тестовый классы ProjectA в ProjectB для целей разработки, то раздел зависимостей в build.gradle в ProjectB будет выглядеть следующим образом:

dependencies {

  compile project(':projecta')

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

}

Некоторые из других ответов так или иначе вызывали ошибки - Gradle не обнаружил тестовые классы из других проектов или проект Eclipse имел недопустимые зависимости при импорте. Если у кого-то есть такая же проблема, я предлагаю перейти с:

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

Первая строка заставляет Eclipse связать другой проект как зависимость, поэтому все источники включены и обновлены. Второй позволяет Gradle фактически видеть источники, не вызывая при этом каких-либо недопустимых ошибок зависимости, как это testCompile project(':core').sourceSets.test.outputделает.

Здесь, если вы используете Kotlin DSL , вы должны создать свою задачу в соответствии с документацией Gradle .

Как и в предыдущем ответе, вам нужно создать специальную конфигурацию внутри проекта, которая будет использовать класс тестов, чтобы вы не смешивали тестовые и основные классы.

Простые шаги

1. В проекте A вы должны добавить в свой 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. Затем в вашем проекте B в зависимости, вам нужно будет добавить в build.gradle.kts:

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

в проекте B:

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

Кажется, работает в 1.7-RC-2