Include JVM test-runner in export --json output

kubukoz · kubukoz · commit 46899413d02e · 2026-05-06T20:41:35.000+02:00
The runner is added inside Artifacts.apply (gated on addJvmTestRunner) -
after BuildInfo has been materialized, so export --json reported only
user-declared test deps. Extract the runner-version selection (with
legacy fallbacks for old Scala/Java) into a shared helper and call it
from ScopedSources.getScopedBuildInfo and JsonProjectDescriptor.export
so the test scope's dependencies reflect what scala-cli would resolve
at test time. Injection is gated on scope == Test, non-empty sources,
JVM platform, and a Scala (non-Java-only) build, mirroring Artifacts.
diff --git a/modules/build/src/main/scala/scala/build/ScopedSources.scala b/modules/build/src/main/scala/scala/build/ScopedSources.scala
@@ -90,7 +90,7 @@ final case class ScopedSources(
         Sources.InMemory(
           Left("build-info"),
           os.rel / "BuildInfo.scala",
-          value(buildInfo(combinedOptions, workspace)).generateContents().getBytes(
+          value(buildInfo(combinedOptions, workspace, logger)).generateContents().getBytes(
             StandardCharsets.UTF_8
           ),
           None
@@ -123,7 +123,11 @@ final case class ScopedSources(
     buildOptionsFor(scope)
       .foldRight(baseOptions)(_.orElse(_))
 
-  def buildInfo(baseOptions: BuildOptions, workspace: os.Path): Either[BuildException, BuildInfo] =
+  def buildInfo(
+    baseOptions: BuildOptions,
+    workspace: os.Path,
+    logger: Logger
+  ): Either[BuildException, BuildInfo] =
     either {
       def getScopedBuildInfo(scope: Scope): ScopedBuildInfo =
         val combinedOptions = combinedBuildOptions(scope, baseOptions)
@@ -133,7 +137,7 @@ final case class ScopedSources(
             unwrappedScripts.flatMap(_.valueFor(scope).toSeq).flatMap(_.originalPath.toOption))
             .map(_._2.toString)
 
-        ScopedBuildInfo(combinedOptions, sourcePaths ++ inMemoryPaths)
+        ScopedBuildInfo.forScope(combinedOptions, sourcePaths ++ inMemoryPaths, scope, logger)
 
       val baseBuildInfo = value(BuildInfo(combinedBuildOptions(Scope.Main, baseOptions), workspace))
 
diff --git a/modules/cli/src/main/scala/scala/cli/exportCmd/JsonProjectDescriptor.scala b/modules/cli/src/main/scala/scala/cli/exportCmd/JsonProjectDescriptor.scala
@@ -16,16 +16,16 @@ final case class JsonProjectDescriptor(
     sourcesMain: Sources,
     sourcesTest: Sources
   ): Either[BuildException, JsonProject] = {
-    def getScopedBuildInfo(options: BuildOptions, sources: Sources) =
+    def getScopedBuildInfo(options: BuildOptions, sources: Sources, scope: Scope) =
       val sourcePaths   = sources.paths.map(_._1.toString)
       val inMemoryPaths = sources.inMemory.flatMap(_.originalPath.toSeq.map(_._2.toString))
 
-      ScopedBuildInfo(options, sourcePaths ++ inMemoryPaths)
+      ScopedBuildInfo.forScope(options, sourcePaths ++ inMemoryPaths, scope, logger)
 
     for {
       baseBuildInfo <- BuildInfo(optionsMain, workspace)
-      mainBuildInfo = getScopedBuildInfo(optionsMain, sourcesMain)
-      testBuildInfo = getScopedBuildInfo(optionsTest, sourcesTest)
+      mainBuildInfo = getScopedBuildInfo(optionsMain, sourcesMain, Scope.Main)
+      testBuildInfo = getScopedBuildInfo(optionsTest, sourcesTest, Scope.Test)
     } yield JsonProject(baseBuildInfo
       .withScope(Scope.Main.name, mainBuildInfo)
       .withScope(Scope.Test.name, testBuildInfo))
diff --git a/modules/integration/src/test/scala/scala/cli/integration/ExportJsonTestDefinitions.scala b/modules/integration/src/test/scala/scala/cli/integration/ExportJsonTestDefinitions.scala
@@ -212,6 +212,139 @@ abstract class ExportJsonTestDefinitions extends ScalaCliSuite with TestScalaVer
     }
   }
 
+  test("export json injects JVM test-runner into test scope") {
+    val inputs = TestInputs(
+      os.rel / "Main.scala" ->
+        """object Main {
+          |  def main(args: Array[String]): Unit = println("hi")
+          |}
+          |""".stripMargin,
+      os.rel / "unit.test.scala" ->
+        s"""//> using dep org.scalameta::munit::${Constants.munitVersion}
+           |
+           |class MyTest extends munit.FunSuite { test("ok") { assert(true) } }
+           |""".stripMargin
+    )
+    inputs.fromRoot { root =>
+      val exportJsonProc =
+        os.proc(TestUtil.cli, "--power", "export", "--json", ".", "--jvm", "temurin:17")
+          .call(cwd = root)
+      val jsonContents     = readJson(exportJsonProc.out.text())
+      val expectedFullName = s"test-runner_${Constants.scala3NextPrefix.split('.').head}"
+      // The test scope should include both munit and the scala-cli test-runner.
+      expect(jsonContents.contains("\"name\":\"test-runner\""))
+      expect(jsonContents.contains(s"\"fullName\":\"$expectedFullName\""))
+      expect(jsonContents.contains("\"groupId\":\"org.virtuslab.scala-cli\""))
+      expect(jsonContents.contains("\"name\":\"munit\""))
+    }
+  }
+
+  test("export json includes JVM test-runner even when no test framework dep is declared") {
+    val inputs = TestInputs(
+      os.rel / "Main.scala" ->
+        """object Main {
+          |  def main(args: Array[String]): Unit = println("hi")
+          |}
+          |""".stripMargin,
+      os.rel / "unit.test.scala" ->
+        """class MyTest { def foo() = () }
+          |""".stripMargin
+    )
+    inputs.fromRoot { root =>
+      val exportJsonProc =
+        os.proc(TestUtil.cli, "--power", "export", "--json", ".", "--jvm", "temurin:17")
+          .call(cwd = root)
+      val jsonContents = readJson(exportJsonProc.out.text())
+      expect(jsonContents.contains("\"name\":\"test-runner\""))
+      expect(jsonContents.contains("\"groupId\":\"org.virtuslab.scala-cli\""))
+    }
+  }
+
+  test("export json includes legacy JVM test-runner for Scala 2.12") {
+    val inputs = TestInputs(
+      os.rel / "Main.scala" ->
+        """object Main {
+          |  def main(args: Array[String]): Unit = println("hi")
+          |}
+          |""".stripMargin,
+      os.rel / "unit.test.scala" ->
+        """class MyTest { def foo() = () }
+          |""".stripMargin
+    )
+    inputs.fromRoot { root =>
+      val exportJsonProc =
+        os.proc(
+          TestUtil.cli,
+          "--power",
+          "export",
+          "--json",
+          ".",
+          "--jvm",
+          "temurin:17",
+          "--scala",
+          Constants.scala212
+        )
+          .call(cwd = root)
+      val jsonContents = readJson(exportJsonProc.out.text())
+      expect(jsonContents.contains("\"fullName\":\"test-runner_2.12\""))
+      expect(jsonContents.contains("\"groupId\":\"org.virtuslab.scala-cli\""))
+      expect(jsonContents.contains(s"\"version\":\"${Constants.runnerScala2LegacyVersion}\""))
+    }
+  }
+
+  test("export json includes legacy JVM test-runner for Scala 2.13") {
+    val inputs = TestInputs(
+      os.rel / "Main.scala" ->
+        """object Main {
+          |  def main(args: Array[String]): Unit = println("hi")
+          |}
+          |""".stripMargin,
+      os.rel / "unit.test.scala" ->
+        """class MyTest { def foo() = () }
+          |""".stripMargin
+    )
+    inputs.fromRoot { root =>
+      val exportJsonProc =
+        os.proc(
+          TestUtil.cli,
+          "--power",
+          "export",
+          "--json",
+          ".",
+          "--jvm",
+          "temurin:17",
+          "--scala",
+          Constants.scala213
+        )
+          .call(cwd = root)
+      val jsonContents = readJson(exportJsonProc.out.text())
+      expect(jsonContents.contains("\"fullName\":\"test-runner_2.13\""))
+      expect(jsonContents.contains("\"groupId\":\"org.virtuslab.scala-cli\""))
+      expect(jsonContents.contains(s"\"version\":\"${Constants.runnerScala2LegacyVersion}\""))
+    }
+  }
+
+  test("export json does not inject test-runner for Native target") {
+    val inputs = TestInputs(
+      os.rel / "Main.scala" ->
+        """object Main {
+          |  def main(args: Array[String]): Unit = println("hi")
+          |}
+          |""".stripMargin,
+      os.rel / "unit.test.scala" ->
+        """class MyTest { def foo() = () }
+          |""".stripMargin
+    )
+    inputs.fromRoot { root =>
+      val exportJsonProc =
+        os.proc(TestUtil.cli, "--power", "export", "--json", ".", "--native")
+          .call(cwd = root)
+      val jsonContents = readJson(exportJsonProc.out.text())
+      expect(!jsonContents.contains("\"name\":\"test-runner\""))
+      expect(!jsonContents.contains("org.virtuslab.scala-cli"))
+    }
+  }
+
   test("export json with js") {
     val inputs = TestInputs(
       os.rel / "Main.scala" ->
diff --git a/modules/options/src/main/scala/scala/build/Artifacts.scala b/modules/options/src/main/scala/scala/build/Artifacts.scala
@@ -118,6 +118,79 @@ object Artifacts {
     addScalapy: Option[String]
   )
 
+  /** Selects the test-runner module version that scala-cli would resolve at test time.
+    *
+    * Falls back to a legacy version when the Scala or Java version is no longer supported by the
+    * current test-runner module. Mirrors the logic used inside [[Artifacts.apply]] so the export
+    * stays faithful to what test-time resolution would produce.
+    */
+  def jvmTestRunnerVersion(
+    scalaVersion: String,
+    jvmVersion: Int,
+    logger: Logger,
+    logLegacyWarnings: Boolean
+  ): String = {
+    val shouldUseLegacyJava8Runners  = jvmVersion < Constants.scala38MinJavaVersion
+    val shouldUseLegacyScala3Runners =
+      scalaVersion.startsWith("3") &&
+      scalaVersion.coursierVersion < s"$scala3LtsPrefix.0".coursierVersion
+    val shouldUseLegacyScala2Runners = scalaVersion.startsWith("2")
+    val shouldUseLegacyScalaRunners  = shouldUseLegacyScala3Runners || shouldUseLegacyScala2Runners
+    val shouldUseLegacyRunners       = shouldUseLegacyScalaRunners || shouldUseLegacyJava8Runners
+
+    val runnerLegacyVersion =
+      if scalaVersion.startsWith("3") then runnerScala30LegacyVersion
+      else runnerScala2LegacyVersion
+
+    if shouldUseLegacyRunners then {
+      if logLegacyWarnings then {
+        if shouldUseLegacyScalaRunners then
+          logger.message(
+            s"$warnPrefix Scala $scalaVersion is no longer supported by the test-runner module."
+          )
+        if shouldUseLegacyJava8Runners then
+          logger.message(
+            s"$warnPrefix Java $jvmVersion is no longer supported by the test-runner module."
+          )
+        logger.message(
+          s"$warnPrefix Defaulting to a legacy test-runner module version: $runnerLegacyVersion."
+        )
+        if shouldUseLegacyScalaRunners then
+          logger.message(
+            s"$warnPrefix To use the latest test-runner, upgrade Scala to at least $scala3LtsPrefix."
+          )
+        if shouldUseLegacyJava8Runners then
+          logger.message(
+            s"$warnPrefix To use the latest test-runner, upgrade Java to at least ${Constants.defaultJavaVersion}."
+          )
+      }
+      runnerLegacyVersion
+    }
+    else testRunnerVersion
+  }
+
+  /** The test-runner dependency rendered for [[scala.build.info.ExportDependencyFormat]] consumers
+    * (e.g. `scala-cli export --json`).
+    *
+    * The artifact name is `test-runner_<scalaBinaryVersion>` to match how scala-cli resolves it at
+    * test time.
+    */
+  def jvmTestRunnerExportDependency(
+    scalaVersion: String,
+    scalaBinaryVersion: String,
+    jvmVersion: Int,
+    logger: Logger
+  ): scala.build.info.ExportDependencyFormat = {
+    import scala.build.info.{ArtifactId, ExportDependencyFormat}
+    val version  = jvmTestRunnerVersion(scalaVersion, jvmVersion, logger, logLegacyWarnings = false)
+    val fullName = s"$testRunnerModuleName${"_"}$scalaBinaryVersion"
+    ExportDependencyFormat(
+      groupId = testRunnerOrganization,
+      artifactId = ArtifactId(testRunnerModuleName, fullName),
+      version = version
+    )
+  }
+
   def apply(
     scalaArtifactsParamsOpt: Option[ScalaArtifactsParams],
     javacPluginDependencies: Seq[Positioned[AnyDependency]],
@@ -159,34 +232,8 @@ object Artifacts {
 
     val jvmTestRunnerDependencies =
       if addJvmTestRunner then {
-        val runnerLegacyVersion =
-          if scalaVersion.startsWith("3")
-          then runnerScala30LegacyVersion
-          else runnerScala2LegacyVersion
         val testRunnerVersion0 =
-          if shouldUseLegacyRunners then {
-            if shouldUseLegacyScalaRunners then
-              logger.message(
-                s"$warnPrefix Scala $scalaVersion is no longer supported by the test-runner module."
-              )
-            if shouldUseLegacyJava8Runners then
-              logger.message(
-                s"$warnPrefix Java $jvmVersion is no longer supported by the test-runner module."
-              )
-            logger.message(
-              s"$warnPrefix Defaulting to a legacy test-runner module version: $runnerLegacyVersion."
-            )
-            if shouldUseLegacyScalaRunners then
-              logger.message(
-                s"$warnPrefix To use the latest test-runner, upgrade Scala to at least $scala3LtsPrefix."
-              )
-            if shouldUseLegacyJava8Runners then
-              logger.message(
-                s"$warnPrefix To use the latest test-runner, upgrade Java to at least ${Constants.defaultJavaVersion}."
-              )
-            runnerLegacyVersion
-          }
-          else testRunnerVersion
+          jvmTestRunnerVersion(scalaVersion, jvmVersion, logger, logLegacyWarnings = true)
         Seq(dep"$testRunnerOrganization::$testRunnerModuleName:$testRunnerVersion0")
       }
       else Nil
diff --git a/modules/options/src/main/scala/scala/build/info/ScopedBuildInfo.scala b/modules/options/src/main/scala/scala/build/info/ScopedBuildInfo.scala
@@ -5,7 +5,8 @@ import coursier.maven.MavenRepository
 import coursier.{Dependency, LocalRepositories, Repositories}
 import dependency.AnyDependency
 
-import scala.build.options.{BuildOptions, ConfigMonoid}
+import scala.build.Logger
+import scala.build.options.{BuildOptions, ConfigMonoid, Platform, Scope}
 
 final case class ScopedBuildInfo(
   sources: Seq[String] = Nil,
@@ -61,6 +62,47 @@ object ScopedBuildInfo {
     )
       .reduceLeft(_ + _)
 
+  /** Build a [[ScopedBuildInfo]] for [[scope]] and inject the JVM test-runner dependency that
+    * scala-cli silently adds at test time, so consumers of `export --json` see the same classpath
+    * scala-cli would use.
+    *
+    * Injection conditions match [[scala.build.Artifacts.apply]]: scope is Test, the scope is
+    * non-empty (has sources), the platform is JVM, and the build has a Scala version (i.e. is not
+    * Java-only).
+    */
+  def forScope(
+    options: BuildOptions,
+    sourcePaths: Seq[String],
+    scope: Scope,
+    logger: Logger
+  ): ScopedBuildInfo = {
+    val base = apply(options, sourcePaths)
+    if scope == Scope.Test && sourcePaths.nonEmpty then
+      withJvmTestRunner(base, options, logger)
+    else base
+  }
+
+  private def withJvmTestRunner(
+    base: ScopedBuildInfo,
+    options: BuildOptions,
+    logger: Logger
+  ): ScopedBuildInfo = {
+    val isJvm        = options.platform.value == Platform.JVM
+    val scalaParams  = options.scalaParams.toOption.flatten
+    val isScalaBuild = scalaParams.nonEmpty
+    if isJvm && isScalaBuild then {
+      val params  = scalaParams.get
+      val dep     = scala.build.Artifacts.jvmTestRunnerExportDependency(
+        scalaVersion = params.scalaVersion,
+        scalaBinaryVersion = params.scalaBinaryVersion,
+        jvmVersion = options.javaHome().value.version,
+        logger = logger
+      )
+      base.copy(dependencies = base.dependencies :+ dep)
+    }
+    else base
+  }
+
   private def scalacOptionsSettings(options: BuildOptions): ScopedBuildInfo =
     ScopedBuildInfo(scalacOptions = options.scalaOptions.scalacOptions.toSeq.map(_.value.value))
 
