Question about Trait structure

[lostiniceland]

I am having trouble defining a test module which has another language than its parent module. While developing the groovylib I am encountering the issue that I cannot create a test-module which has a different language than the parent module. In my case, I want the tests to be a GroovyMavenTest module while the parent is a plain JavaModule with MavenModule. Even though less likely, this problem will also show up when you want to use Kotlin only for your tests or Scala (like when using Gatlin).

Maybe I am just missing the right way to define the module but this is what I currently have.

trait GroovyMavenModule extends GroovyModule with MavenModule {
  private def sources0 = Task.Sources("src/main/groovy")
  override def sources = super.sources() ++ sources0()

  trait GroovyMavenTests extends GroovyTests with MavenTests {
    override def sources = Task.Sources(
      moduleDir / "src" / testModuleName / "java",
      moduleDir / "src" / testModuleName / "groovy"
    )
  }
}

This follows the conventions used for all module traits in Mill, where the test-trait is defined within the parent trait.
I would like to define it like this

object `package` extends JavaModule
{

  ...

  object test extends GroovyMavenTests {

    ...

  }
}

But this is not possible, because GroovyMavenTests is defined within GroovyModule. I need to make the parent a GroovyModule

object `package` extends GroovyMavenModule
{

    object test extends GroovyMavenTests {
  }
}

But this is wrong, and pollutes my main module with Groovy dependencies.

I tried to work around this by defining a local trait like this

package build
trait TestOnlyGroovyModule extends GroovyMavenModule {

  def groovyVersion = "4.0.28"

  object test extends GroovyMavenTests with TestModule.Junit5 {
    def bomMvnDeps = Seq(
      mvn"org.apache.groovy:groovy-bom:${Versions.groovy}",
    )
  }
}

But this result is duplicate module test when using it like this.

object `package` extends JavaModule
{
  object test extends build.TestOnlyGroovyModule {
 }
}

Is this a design constraint, or am I missing something? As said, with my current understanding I would not be possible to define a test module with another language than its parent due to the trait structure.

[lefou]

The idea behind the language-specific inner test traits is, that you can can spare some redundant configuration steps, since typically test modules share their language setup with their base module. If this is not the case for you, you don't get much from a language-specific test trait, since it can't copy the specific settings from the base/outer module anyways. All that's needed to run tests is a TestModule. The convenience traits mostly provide convenience, e.g. they include the outer module to the moduleDeps and setup the source dirs to match the layout of the outer module.

If you have a Java base module foo and want to use another language in the tests, e.g. Scala, you can
mix-in the respective language module, in this case ScalaModule into the available test module trait.

object foo extends JavaModule {
  object test extends ScalaModule with JavaTests {
  }
}

• ScalaModule will enable the Scala-specific tooling
• JavaTests will add the test toolchain and some adaptions derived from the outer foo module like the dependencies an the source dirs.

[lefou]

So imagine, you have a GroovyMavenModule which follows the coding style of other Mill modules, your setup may look like this:

object `package` extends JavaMavenModule {
  object test extends GroovyModule, JavaMavenTests {
  }
}

You probably need to add the src/test/grooy directory explicitly.

[lostiniceland]

Thanks, that helped. Then I will try to provide a convenience-trait for this case as well.