Can I get maven to generate two test jars with different classifiers? - unit-testing

Question

I have a maven project where I generate some test code for some modules. I'd like this generated test code to be available for testing by other modules. Typically if the module bar wants to use the test code of module foo, the foo module must generate a foo-tests.jar and the module bar adds a dependency such as:
<dependency>
<artifactId>foo</artifactId>
<classifier>tests</classifier>
<scope>test</scope>
</dependency>
Which is fine, except that I only want to pull in the generated test code of foo, not all of foo's unit tests and helper classes (there may be unintended class conflicts, for example). I'd like to define a dependency such as:
<dependency>
<artifactId>foo</artifactId>
<classifier>test-libs</classifier>
<scope>test</scope>
</dependency>
Typically maven-jar-plugin is used to generate the foo-test artifact, so I was hoping I could configure that plugin to generate two test artifacts: one that contains the usual test code (unit tests, etc) in foo-tests and one that contains the generated code in foo-test-libs, using two different classifiers, e.g.:
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<executions>
<execution>
<id>generate-test-jar</id>
<phase>package</package>
<goals><goal>test-jar</goal></goals>
<configuration>
<excludes>... all the generated code ...</excludes>
</configuration>
</execution>
<execution>
<id>generate-test-libs-jar</id>
<phase>package</package>
<goals><goal>test-jar</goal></goals>
<classifier>test-libs</classifier>
<configuration>
<includes>... all the generated code ...</includes>
</configuration>
</execution>
</executions>
</plugin>
The problem here is that, unlike the jar goal, the test-jar goal of maven-jar-plugin does not support the classifier element. I assume the goal uses the test classifier by default, so I cannot generated two test jars with different classifiers.
I am wondering if there's a good way of splitting the test jars for a maven module? If all else fails, I can go back to adding dependencies on the complete test jar, but I'm hoping for a more elegant solution.
(And I know that using classifier is frowned upon, but I'm not sure if it can be avoided here ...)

Answer 1

I think I figured it out, using a combination of maven-antrun-plugin to create multiple test jar files (using the jar task), and build-helper-maven-plugin to attach the generated jar file as artifacts to the project.
Generate test jar files.
I use maven-antrun-plugin combined with the ant jar task to split my test code:
<plugin>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.7</version>
<executions>
<execution>
<phase>package</phase>
<goals><goal>run</goal></goals>
<configuration>
<target>
<!-- The test-libs jar contains all test code in the x.y.z package. -->
<jar destfile="${project.build.directory}/artifacts/test-libs/${project.build.finalName}.jar"
basedir="${project.build.directory}/test-classes"
includes="x/y/z/**/*.class"/>
<!-- The tests jar contains all test code exception the x.y.z package. -->
<jar destfile="${project.build.directory}/artifacts/tests/${project.build.finalName}.jar"
basedir="${project.build.directory}/test-classes"
excludes="x/y/z/**/*.class"/>
</target>
</configuration>
</execution>
</executions>
</plugin>
Note that I had to use the same name ${project.build.finalName}.jar for each generated jar file (this is important later) so I put each jar file into its own directory:
target/artifacts/test-libs/foo.jar
target/artifacts/tests/foo.jar
Attaching the jar files to the project.
Generating the jar files is only the first step. The jar files need to be attached to the maven project so that they will be installed. For this the build-helper-maven-plugin is required. This allows attaching of files as artifacts, where each file has a location, a type, and a classifier. Here the type is jar and the classifier will be tests or test-libs as appropriate:
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<version>1.9</version>
<executions>
<execution>
<id>attach-test-jars</id>
<phase>package</phase>
<goals><goal>attach-artifact</goal></goals>
<configuration>
<artifacts>
<!-- Attach the test-libs artifact. -->
<artifact>
<file>${project.build.directory}/artifacts/test-libs/${project.build.finalName}.jar</file>
<type>jar</type>
<classifier>test-libs</classifier>
</artifact>
<!-- Attach the tests artifact. -->
<artifact>
<file>${project.build.directory}/artifacts/tests/${project.build.finalName}.jar</file>
<type>jar</type>
<classifier>tests</classifier>
</artifact>
</artifacts>
</configuration>
</execution>
</executions>
</plugin>
With this I now see the following output:
[INFO] Installing ...\target\artifacts\test-libs\foo-1.0.jar to ...\foo\1.0\foo-1.0-test-libs.jar
[INFO] Installing ...\target\artifacts\tests\foo-1.0.jar to ...\foo\1.0\foo-1.0-tests.jar
[INFO] Installing ...\target\foo-1.0.jar to ...\foo\1.0\foo-1.0.jar
My other projects can now add dependencies on either foo-test.jar or foo-test-lib.jar as required. Huzzah!