manage BOMs in Tests

Starting with JUnit 5.12 and Spock 2.3 a BOM is available on Maven Central.
If the version matches the BOMs will be automatically added.

For JUnit, this has the effect that the platform-launcher is also managed in the BOM so it is actually not necessary to specify a platform-launcher-version. Hence the launcher is also added when the version is not set and the minimum version is met.

Author: lostiniceland

libs/groovylib/package.mill

@@ -7,7 +7,7 @@ import millbuild.*
 
 object `package` extends MillPublishScalaModule with BuildInfo {
 
-  def moduleDeps = Seq(build.libs.javalib, build.libs.javalib.testrunner, api)
+  def moduleDeps = Seq(build.libs.util, build.libs.javalib, build.libs.javalib.testrunner, api)
   def localTestExtraModules: Seq[MillJavaModule] =
     super.localTestExtraModules ++ Seq(worker)
 

libs/groovylib/src/mill/groovylib/GroovyModule.scala

@@ -10,6 +10,7 @@ import mill.*
 import mainargs.Flag
 import mill.api.daemon.internal.bsp.{BspBuildTarget, BspModuleApi}
 import mill.javalib.api.internal.{JavaCompilerOptions, JvmWorkerApi, ZincCompileJava}
+import mill.util.Version
 
 /**
  * Core configuration required to compile a single Groovy module.
@@ -28,8 +29,18 @@ trait GroovyModule extends JavaModule with GroovyModuleApi { outer =>
    */
   def groovyLanguageVersion: T[String] = Task { groovyVersion().split("[.]").take(2).mkString(".") }
 
+  private def isGroovyBomAvailable: T[Boolean] = Task {
+    if (groovyVersion().isBlank) {
+      false
+    } else {
+      Version.isAtLeast(groovyVersion(), "4.0.26")(using Version.IgnoreQualifierOrdering)
+    }
+  }
+
   override def bomMvnDeps: T[Seq[Dep]] = super.bomMvnDeps() ++
-    Seq(mvn"org.apache.groovy:groovy-bom:${groovyVersion()}")
+    Seq(groovyVersion())
+      .filter(_.nonEmpty && isGroovyBomAvailable())
+      .map(v => mvn"org.apache.groovy:groovy-bom:$v")
 
   /**
    * All individual source files fed into the compiler.

libs/groovylib/test/src/mill/groovylib/HelloGroovyTests.scala

@@ -2,7 +2,7 @@ package mill
 package groovylib
 
 import mill.javalib.{JavaModule, TestModule}
-import mill.api.{Task}
+import mill.api.Task
 import mill.api.Discover
 import mill.testkit.{TestRootModule, UnitTester}
 import utest.*
@@ -11,6 +11,7 @@ object HelloGroovyTests extends TestSuite {
 
   val groovy4Version = "4.0.28"
   val junit5Version = sys.props.getOrElse("TEST_JUNIT5_VERSION", "5.13.4")
+  val spockGroovy4Version = "2.3-groovy-4.0"
 
   object HelloGroovy extends TestRootModule {
 
@@ -25,12 +26,8 @@ object HelloGroovyTests extends TestSuite {
           HelloGroovy.`groovy-tests`
         )
 
-        override def groovyVersion = groovy4Version
-        override def depManagement = Seq(
-          mvn"org.junit.jupiter:junit-jupiter-engine:$junit5Version"
-        )
-        override def jupiterVersion = junit5Version
-        override def junitPlatformVersion = "1.13.4"
+        override def groovyVersion: T[String] = groovy4Version
+        override def jupiterVersion: T[String] = junit5Version
       }
 
     }
@@ -40,38 +37,53 @@ object HelloGroovyTests extends TestSuite {
       override def mainClass = Some("jointcompile.JavaMain")
     }
 
+    object deps extends Module {
+
+      object groovyBom extends GroovyModule {
+        override def groovyVersion: T[String] = groovy4Version
+      }
+
+      object groovyNoBom extends GroovyModule {
+        // Groovy-BOM available starting with 4.0.26
+        override def groovyVersion: T[String] = "4.0.25"
+      }
+
+      object `spockBom` extends GroovyModule with TestModule.Spock {
+        override def spockVersion: T[String] = spockGroovy4Version
+        override def groovyVersion: T[String] = groovy4Version
+      }
+
+      object `spockNoBom` extends GroovyModule with TestModule.Spock {
+        // Groovy-BOM available starting with 2.3
+        override def spockVersion: T[String] = "2.2-groovy-4.0"
+        override def groovyVersion: T[String] = groovy4Version
+      }
+
+    }
+
     trait Test extends GroovyModule {
 
       override def mainClass = Some("hello.Hello")
 
       object test extends GroovyTests with TestModule.Junit5 {
-        override def depManagement = Seq(
-          mvn"org.junit.jupiter:junit-jupiter-engine:5.13.4"
-        )
-        override def jupiterVersion = "5.13.4"
+        override def jupiterVersion: T[String] = junit5Version
         override def junitPlatformVersion = "1.13.4"
       }
 
       object script extends GroovyModule {
-        override def groovyVersion = "4.0.28"
+        override def groovyVersion: T[String] = groovy4Version
         override def mainClass = Some("HelloScript")
       }
 
       object staticcompile extends GroovyModule {
-        override def groovyVersion = "4.0.28"
+        override def groovyVersion: T[String] = groovy4Version
         override def mainClass = Some("hellostatic.HelloStatic")
       }
 
       object spock extends GroovyTests with TestModule.Spock {
-        override def junitPlatformVersion = "1.13.4"
-        override def spockVersion = "2.3-groovy-4.0"
-        override def groovyVersion = "4.0.28"
-
-        def bomMvnDeps = Seq(
-          mvn"org.junit:junit-bom:5.13.4",
-//          mvn"org.apache.groovy:groovy-bom:${groovyVersion()}",
-          mvn"org.spockframework:spock-bom:${spockVersion()}"
-        )
+        override def jupiterVersion: T[String] = junit5Version
+        override def spockVersion: T[String] = spockGroovy4Version
+        override def groovyVersion: T[String] = groovy4Version
       }
     }
     object main extends Test {
@@ -91,6 +103,7 @@ object HelloGroovyTests extends TestSuite {
     def m = HelloGroovy.main
     def mixed = HelloGroovy.`groovy-tests`
     def joint = HelloGroovy.`joint-compile`
+    def deps = HelloGroovy.deps
 
     test("running a Groovy script") {
       testEval().scoped { eval =>
@@ -183,5 +196,57 @@ object HelloGroovyTests extends TestSuite {
       }
     }
 
+    test("dependency management") {
+
+      test("groovy") {
+
+        val groovyBom = mvn"org.apache.groovy:groovy-bom:$groovy4Version"
+
+        test("groovy bom is added when version is at least 4.0.26") {
+          testEval().scoped { eval =>
+            val Right(result) = eval.apply(deps.groovyBom.bomMvnDeps): @unchecked
+
+            assert(
+              result.value.contains(groovyBom)
+            )
+          }
+        }
+
+        test("groovy bom is NOT added when version is below 4.0.26") {
+          testEval().scoped { eval =>
+            val Right(result) = eval.apply(deps.groovyNoBom.bomMvnDeps): @unchecked
+
+            assert(
+              !result.value.contains(groovyBom)
+            )
+          }
+        }
+      }
+
+      test("spock") {
+
+        val spockBom = mvn"org.spockframework:spock-bom:$spockGroovy4Version"
+
+        test("spock bom is added when version is at least 2.3") {
+          testEval().scoped { eval =>
+            val Right(result) = eval.apply(deps.spockBom.bomMvnDeps): @unchecked
+
+            assert(
+              result.value.contains(spockBom)
+            )
+          }
+        }
+
+        test("spock bom is NOT added when version is below 2.3") {
+          testEval().scoped { eval =>
+            val Right(result) = eval.apply(deps.spockNoBom.bomMvnDeps): @unchecked
+
+            assert(
+              !result.value.contains(spockBom)
+            )
+          }
+        }
+      }
+    }
   }
 }

libs/javalib/src/mill/javalib/TestModule.scala

@@ -9,7 +9,7 @@ import mill.api.Task
 import mill.api.TaskCtx
 import mill.api.DefaultTaskModule
 import mill.javalib.bsp.BspModule
-import mill.util.Jvm
+import mill.util.{Jvm, Version}
 import mill.api.JsonFormatters.given
 import mill.constants.EnvVars
 import mill.javalib.testrunner.{
@@ -358,24 +358,53 @@ object TestModule {
    * You can override the [[junitPlatformVersion]] and [[jupiterVersion]] task
    * or provide the JUnit 5-dependencies yourself.
    *
+   * In case the [[jupiterVersion]] is set (and it is > 5.12), it pulls in JUnit-BOM in [[bomMvnDeps]]. If this is
+   * true, then there is no need to specify the [[junitPlatformVersion]] anymore, because this is managed by the
+   * BOM.
+   *
    * See: https://junit.org/junit5/
    */
   trait Junit5 extends TestModule {
 
-    /** The JUnit 5 Platfrom version to use, or empty, if you want to provide the dependencies yourself. */
+    /** The JUnit 5 Platform version to use, or empty, if you want to provide the dependencies yourself. */
     def junitPlatformVersion: T[String] = Task { "" }
 
-    /** The JUnit Jupiter version to use, or empty, if you want to provide the dependencie yourself. */
+    /** The JUnit Jupiter version to use, or empty, if you want to provide the dependencies yourself. */
     def jupiterVersion: T[String] = Task { "" }
 
+    private def isJupiterBomAvailable: T[Boolean] = Task {
+      if (jupiterVersion().isBlank) {
+        false
+      } else {
+        Version.isAtLeast(jupiterVersion(), "5.12.0")(using Version.IgnoreQualifierOrdering)
+      }
+    }
+
     override def testFramework: T[String] = "com.github.sbt.junit.jupiter.api.JupiterFramework"
 
+    override def bomMvnDeps: T[Seq[Dep]] = Task {
+      super.bomMvnDeps() ++
+        Seq(jupiterVersion())
+          .filter(!_.isBlank() && isJupiterBomAvailable())
+          .flatMap(v =>
+            Seq(
+              mvn"org.junit:junit-bom:${v.trim()}"
+            )
+          )
+    }
+
     override def mandatoryMvnDeps: T[Seq[Dep]] = Task {
       super.mandatoryMvnDeps() ++
         Seq(mvn"${mill.javalib.api.Versions.jupiterInterface}") ++
-        Seq(junitPlatformVersion())
-          .filter(!_.isBlank())
-          .map(v => mvn"org.junit.platform:junit-platform-launcher:${v.trim()}") ++
+        Seq(junitPlatformVersion()).flatMap(v => {
+          if (!v.isBlank) {
+            Some(mvn"org.junit.platform:junit-platform-launcher:${v.trim()}")
+          } else if (isJupiterBomAvailable()) {
+            Some(mvn"org.junit.platform:junit-platform-launcher")
+          } else {
+            None
+          }
+        }) ++
         Seq(jupiterVersion())
           .filter(!_.isBlank())
           .map(v => mvn"org.junit.jupiter:junit-jupiter-api:${v.trim()}")
@@ -603,6 +632,9 @@ object TestModule {
   /**
    * TestModule that uses Spock Test Framework to run tests.
    * You can override the [[spockVersion]] task or provide the Spock dependency yourself.
+   *
+   * In case the version is set, it pulls in Spock-BOM in [[bomMvnDeps]] (only for 2.3 onwards) 
+   * and Spock-Core in [[mvnDeps]]
    */
   trait Spock extends TestModule.Junit5 {
 
@@ -611,12 +643,24 @@ object TestModule {
       ""
     }
 
-    /** The Groovy version to use, or the empty string, if you want to provide the Groovy test dependency yourself. */
-    def groovyVersion: T[String] = Task {
-      ""
+    private def isSpockBomAvailable: T[Boolean] = Task {
+      if (spockVersion().isBlank) {
+        false
+      } else {
+        Version.isAtLeast(spockVersion(), "2.3")(using Version.IgnoreQualifierOrdering)
+      }
     }
 
-    // TODO currently bomMvnDeps not in JavaModuleBase so we cannot pull in the Spock-BOM
+    override def bomMvnDeps: T[Seq[Dep]] = Task {
+      super.bomMvnDeps() ++
+        Seq(spockVersion())
+          .filter(!_.isBlank() && isSpockBomAvailable())
+          .flatMap(v =>
+            Seq(
+              mvn"org.spockframework:spock-bom:${v.trim()}"
+            )
+          )
+    }
 
     override def mandatoryMvnDeps: T[Seq[Dep]] = Task {
       super.mandatoryMvnDeps() ++
@@ -650,6 +694,7 @@ object TestModule {
     def mvnDeps: T[Seq[Dep]] = Seq()
     def mandatoryMvnDeps: T[Seq[Dep]] = Seq()
     def resources: T[Seq[PathRef]] = Task { Seq.empty[PathRef] }
+    def bomMvnDeps: T[Seq[Dep]] = Seq()
   }
 
   trait ScalaModuleBase extends mill.Module {