I have a multi-project configuration and I want to use gradle.
My projects are like this:
Project A
src/main/javasrc/test/javaProject B
src/main/java (depends on src/main/java on Project A) src/test/java (depends on src/test/java on Project A) My Project B build.gradle file is like this:
apply plugin: 'java'
dependencies {
compile project(':ProjectA')
}
The task compileJava work great but the compileTestJava does not compile the test file from Project A.
In Project B, you just need to add a testCompile dependency:
dependencies {
...
testCompile project(':A').sourceSets.test.output
}
Tested with Gradle 1.7.
gradle testClasses before the build structure is actually valid. E.g. the Eclipse plugin won't let you import the project before that. It really is a shame testCompile project(':A') does not work. @DavidPärsson: "Gradle 1.3" contradicts "no longer" since Fesler tested with Gradle 1.7. –
Loney eclipse task. –
Melliemelliferous This is now supported as a first class feature in Gradle. Modules with java or java-library plugins can also include a java-test-fixtures plugin which exposes helper classes and resources to be consumed with testFixtures helper. Benefit of this approach against artifacts and classifiers are:
Only relevant lines shown here, see GitHub for the full compiling example.
:modul:oneplugins {
id("java-library") // or "java"
id("java-test-fixtures")
}
package com.example;
public class Helper {}
:modul:otherplugins {
id("java") // or "java-library"
}
dependencies {
testImplementation(testFixtures(project(":modul:one")))
}
package com.example.other;
import com.example.Helper;
public class SomeTest {
@Test public void f() {
new Helper(); // used from :modul:one's testFixtures
}
}
For more info, see the documentation:
https://docs.gradle.org/current/userguide/java_testing.html#sec:java_test_fixtures
It was added in Gradle 5.6:
https://docs.gradle.org/5.6/release-notes.html#test-fixtures-for-java-projects
On Android Java test-fixtures support was added in AGP 7.1
Using Kotlin language in test-fixtures source set in JVM projects is possible, not sure when it was added exactly, let's say 2022: Kotlin 1.7.
Using Kotlin language in test-fixtures on Android: JetBrains is refusing to implement it here and Google just keeps punting it from one release to the next and the community is just yearning (look at the number of votes).
testFixtures dependency could be written as testFixturesImplementation in case of sharing "java-test-fixtures" plugin. See docs.gradle.org/current/userguide/… –
Schweiker testFixtures: are you inside a dependencies block? we're supposed to be calling org.gradle.api.artifacts.dsl.DependencyHandler#testFixtures(java.lang.Object) if the unresolved reference is testImplementation: are do you have a Java plugin (one of java/java-library/java-application) applied directly or transitively, and are you inside the dependencies block? If neither, please Google the error as it's unlikely to be related. –
Sturgis dependencies block inside kotlin { }? If not, could you try to reproduce with a pull request to the example? –
Sturgis Simple way is to add explicit task dependency in ProjectB:
compileTestJava.dependsOn tasks.getByPath(':ProjectA:testClasses')
Difficult (but more clear) way is to create additional artifact configuration for ProjectA:
task myTestsJar(type: Jar) {
// pack whatever you need...
}
configurations {
testArtifacts
}
artifacts {
testArtifacts myTestsJar
}
and add the testCompile dependency for ProjectB
apply plugin: 'java'
dependencies {
compile project(':ProjectA')
testCompile project(path: ':ProjectA', configuration: 'testArtifacts')
}
testArtifacts configuration like this: configurations { testArtifacts } for more details see this section of Gradle help: gradle.org/docs/current/dsl/… –
Satyr from sourceSets.test.output and possibly classifier = 'tests' in place of // pack whatever you need... in the answer –
Campestral I've come across this problem myself recently, and man is this a tough issues to find answers for.
The mistake you are making is thinking that a project should export its test elements in the same way that it exports its primary artifacts and dependencies.
What I had a lot more success with personally was making a new project in Gradle. In your example, I would name it
Project A_Test -> src/main/java
I would put into the src/main/java the files that you currently have in Project A/src/test/java. Make any testCompile dependencies of your Project A compile dependencies of Project A_Test.
Then make Project A_Test a testCompile dependency of Project B.
It's not logical when you come at it from the perspective of the author of both projects, but I think it makes a lot of sense when you think about projects like junit and scalatest (and others. Even though those frameworks are testing-related, they are not considered part of the "test" targets within their own frameworks - they produce primary artifacts that other projects just happen to use within their test configuration. You just want to follow that same pattern.
Trying to do the other answers listed here did not work for me personally (using Gradle 1.9), but I've found that the pattern I describe here is a cleaner solution anyway.
testImplementation dependency in B project. –
Schweiker I know it's an old question but I just had the same problem and spent some time figuring out what is going on. I'm using Gradle 1.9. All changes should be in ProjectB's build.gradle
To use test classes from ProjectA in tests of ProjectB:
testCompile files(project(':ProjectA').sourceSets.test.output.classesDir)
To make sure that sourceSets property is available for ProjectA:
evaluationDependsOn(':ProjectA')
To make sure test classes from ProjectA are actually there, when you compile ProjectB:
compileTestJava.dependsOn tasks.getByPath(':ProjectA:testClasses')
.classesDir. –
Rior Please read the update bellow.
Similar problems described by JustACluelessNewbie occurs in IntelliJ IDEA. Problem is that dependency testCompile project(':core').sourceSets.test.output actually means: "depend on classes generated by gradle build task". So if you open clean project where classes are not generated yet IDEA won't recognise them and reports error.
To fix this problem you have to add a dependency on test source files next to dependency on compiled classes.
// First dependency is for IDEA
testCompileOnly files { project(':core').sourceSets.test.java.srcDirs }
// Second is for Gradle
testCompile project(':core').sourceSets.test.output
You can observe dependencies recognised by IDEA in Module Settings -> Dependencies (test scope).
Btw. this is not nice solution so refactoring is worth considering. Gradle itself does have special subproject containing test-support classes only. See https://docs.gradle.org/current/userguide/test_kit.html
Update 2016-06-05 More I am thinking about proposed solution less I like it. There are few problems with it:
So what's the better solution? In my opinion it's creating new custom source set and putting shared classes into it. Actually authors of Gradle project did it by creating testFixtures source set.
To do it you just have to:
Create source set and add necessary configurations. Check this script plugin used in Gradle project: https://github.com/gradle/gradle/blob/v4.0.0/gradle/testFixtures.gradle (or more recent 8.2.1 version)
Declare proper dependency in dependent project:
dependencies {
testCompile project(path: ':module-with-shared-classes', configuration: 'testFixturesUsageCompile')
}
Import Gradle project to IDEA and use the "create separate module per source set" option while importing.
Here if you are using Kotlin DSL, you should create your task like that according to Gradle documentation.
Like some previous answer, you need to create a special configuration inside the project that will share its tests class, so that you don't mix test and main classes.
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"])
}
build.gradle.kts:dependencies {
implementation(project(":ProjectA"))
testImplementation(project(":ProjectA", "test"))
}
New testJar based (trnsitive dependancies supported) solution available as gradle plugin:
https://github.com/hauner/gradle-plugins/tree/master/jartest
https://plugins.gradle.org/plugin/com.github.hauner.jarTest/1.0
From documentation
In case you have a multi-project gradle build you may have test dependencies between sub-projects (which probably is a hint that your projects are not well structured).
For example assume a project where the sub-project Project B depends on Project A and B does not only have a compile dependency on A but also a test dependency. To compile and run the tests of B we need some test helper classes from A.
By default gradle does not create a jar artifact from the test build output of a project.
This plugin adds a testArchives configuration (based on testCompile) and a jarTest task to create a jar from the test source set (with the classifier test added to name of the jar). We can then depend in B on the testArchives configuration of A (which will also include the transitive dependencies of A).
In A we would add the plugin to build.gradle:
apply plugin: 'com.github.hauner.jarTest'In B we reference the testArchives configuration like this:
dependencies {
...
testCompile project (path: ':ProjectA', configuration: 'testArchives')
}
Could not get unknown property 'testClasses' for project ':core' of type org.gradle.api.Project. –
Wollongong I'm so late to the party (it is now Gradle v4.4) but for anyone else who finds this:
Assuming:
~/allProjects
|
|-/ProjectA/module-a/src/test/java
|
|-/ProjectB/module-b/src/test/java
Go to the build.gradle of project B (the one that needs some test classes from A) and add the following:
sourceSets {
String sharedTestDir = "${projectDir}"+'/module-b/src/test/java'
test {
java.srcDir sharedTestDir
}
}
or (assuming your project is named ProjectB)
sourceSets {
String sharedTestDir = project(':ProjectB').file("module-b/src/test/java")
test {
java.srcDir sharedTestDir
}
}
Voila!
projectExposingTests the snippet (kotlin version): sourceSets { test { java.srcDir(project(":projectExposingTests").file("src/test/java")) } } –
Afterbirth The Fesler's solution haven't worked for me, when i tried it to build an android project (gradle 2.2.0). So i had to reference required classes manually :
android {
sourceSets {
androidTest {
java.srcDir project(':A').file("src/androidTest/java")
}
test {
java.srcDir project(':A').file("src/test/java")
}
}
}
@VisibleForTesting lint rules. You won't be able to call such methods from the regular module under not test folder. –
Lipcombe I know that there are many sources telling you, that is not OK, fe:
But this is so damn simple and I just don't like the idea of having common test classes separately in testFixtures folder.
So in module A:
task jarTests(type: Jar, dependsOn: testClasses) {
classifier = 'tests'
from sourceSets.test.output
}
configurations {
tests {
extendsFrom testRuntime
}
}
artifacts {
tests jarTests
}
And in module B:
testImplementation project(':moduleA')
testImplementation project(path: ':moduleA', configuration: 'tests')
And it just works!
test. gradle command line works fine with any name, but at least IntelliJ works better with "test" (because it then understands the dependency is actually to the test sources, you dont want the IDEs to "really" depend on the output jars!) –
Broadloom configurations tests here. If I remember correctly, it should be test (singular, not plural) instead. –
Broadloom If you want to use artifact dependencies to have:
then ProjectB's dependencies section in build.gradle should look something like this:
dependencies {
compile("com.example:projecta:1.0.0")
testCompile("com.example:projecta:1.0.0:tests")
}
For this to work ProjectA needs to build a -tests jar and include it in the artifacts it produces.
ProjectA's build.gradle should contain configuration like this:
task testsJar(type: Jar, dependsOn: testClasses) {
classifier = 'tests'
from sourceSets.test.output
}
configurations {
tests
}
artifacts {
tests testsJar
archives testsJar
}
jar.finalizedBy(testsJar)
When ProjectA's artifacts are published to your artifactory they will include a -tests jar.
The testCompile in ProjectB's dependencies section will bring in the classes in the -tests jar.
If you want to includeFlat ProjectA's source and test classes in ProjectB for development purposes then the dependencies section in ProjectB's build.gradle would look like this:
dependencies {
compile project(':projecta')
testCompile project(path: ':projecta', configuration: 'tests')
}
println(configurations.joinToString("\n") { it.name + " - " + it.allDependencies.joinToString() }) (in a kotlin buildscript), I determined which configurations still exist and have dependencies, but for all of these Gradle complained: Selected configuration 'testCompileClasspath' on 'project :sdk' but it can't be used as a project dependency because it isn't intended for consumption by other components. –
Porkpie extendFrom, the archive inside artifacts and the last part jar.finalize. Thank you (by the way I've test this and it works, but I want to understand the differences with the other answer which I've not tested yet) –
Iconium If you are struggling to adapt the solution to the Gradle Kotlin DSL this is the equivalent:
configurations {
register("testClasses") {
extendsFrom(testImplementation.get())
}
}
val testJar = tasks.register<Jar>("testJar") {
archiveClassifier.set("test")
from(sourceSets.test)
}
artifacts.add("testClasses", testJar)
If you have mock dependencies which you need to share between tests, you can create new project projectA-mock and then add it as test dependency to ProjectA and ProjectB:
dependencies {
testCompile project(':projectA-mock')
}
This is clear solution to share mock dependencies, but if you need to run tests from ProjectA in ProjectB use other solution.
The solution mentioned by Nikita for Android + Kotlin looks like this:
task jarTests(type: Jar, dependsOn: "assembleDebugUnitTest") {
getArchiveClassifier().set('tests')
from "$buildDir/tmp/kotlin-classes/debugUnitTest"
}
configurations {
unitTestArtifact
}
artifacts {
unitTestArtifact jarTests
}
Gradle for project that is going to use dependencies:
testImplementation project(path: ':shared', configuration: 'unitTestArtifact')
Some of the other answers caused errors one way or another - Gradle did not detect test classes from other projects or Eclipse project had invalid dependencies when imported. If anyone has the same problem, I suggest going with:
testCompile project(':core')
testCompile files(project(':core').sourceSets.test.output.classesDir)
The first line forces the Eclipse to link the other project as dependency, so all sources are included and up to date. The second allows Gradle to actually see the sources, while not causing any invalid dependency errors like testCompile project(':core').sourceSets.test.output does.
in project B:
dependencies {
testCompile project(':projectA').sourceSets.test.output
}
Seems to work in 1.7-rc-2
© 2022 - 2024 — McMap. All rights reserved.