Run unit tests with truffle-compiler

build.sbt

@@ -13,8 +13,11 @@ import src.main.scala.licenses.{
   SBTDistributionComponent
 }
 import com.sandinh.javamodule.moduleinfo.JpmsModule
+import com.sandinh.javamodule.moduleinfo.AutomaticModule
+import sbt.librarymanagement.DependencyFilter
 
 import java.io.File
+import scala.collection.mutable.ListBuffer
 
 // ============================================================================
 // === Global Configuration ===================================================
@@ -519,6 +522,105 @@ lazy val componentModulesPaths =
   )
 }
 
+lazy val graalModulesPaths =
+  taskKey[Def.Classpath](
+    "Gathers all GraalVM modules (Jar archives that should be put on module-path" +
+    " as files"
+  )
+(ThisBuild / graalModulesPaths) := {
+  val runnerCp  = (`engine-runner` / Runtime / fullClasspath).value
+  val runtimeCp = (LocalProject("runtime") / Runtime / fullClasspath).value
+  val fullCp    = (runnerCp ++ runtimeCp).distinct
+  val log       = streams.value.log
+  JPMSUtils.filterModulesFromClasspath(
+    fullCp,
+    GraalVM.modules,
+    log,
+    shouldContainAll = true
+  )
+}
+
+/** The javaOptions are created such that the `runtime/test` will run with truffle-compiler
+  * So we need to properly create --module-path option.
+  * Module `org.enso.runtime` is added to --module-path as a path to a directory with
+  * expanded classes, i.e., not a Jar archive. This means we also have to properly create
+  * --patch-module option. This is an optimization so that we don't have to assembly the
+  * `runtime.jar` fat jar for the tests.
+  */
+lazy val modulePathTestOptions =
+  taskKey[Seq[String]](
+    "Provides javaOptions for running tests with --module-path set such that " +
+    "enso (`org.enso.runtime`) module and truffle-compiler and the rest of " +
+    "the GraalVM modules are on module-path. Also makes sure that the `runtime.jar` " +
+    "fat jar is not rebuilt unnecessarily"
+  )
+(ThisBuild / modulePathTestOptions) := {
+  val updateReport = (LocalProject("runtime") / Test / update).value
+  val runtimeModName = (LocalProject(
+    "runtime-with-instruments"
+  ) / moduleInfos).value.head.moduleName
+  val runtimeMod = (LocalProject(
+    "runtime-with-instruments"
+  ) / Compile / productDirectories).value
+  val graalMods = graalModulesPaths.value
+  val loggingMods = JPMSUtils.filterModulesFromUpdate(
+    updateReport,
+    logbackPkg ++ Seq(
+      "org.slf4j" % "slf4j-api" % slf4jVersion
+    ),
+    streams.value.log,
+    shouldContainAll = true
+  )
+
+  /** All these modules will be in --patch-module cmdline option to java, which means that
+    * for the JVM, it will appear that all the classes contained in these sbt projects are contained
+    * in the `org.enso.runtime` module. In this way, we do not have to assembly the `runtime.jar`
+    * fat jar.
+    */
+  val modulesToPatchIntoRuntime: Seq[File] =
+    (LocalProject(
+      "runtime-instrument-common"
+    ) / Compile / productDirectories).value ++
+    (LocalProject(
+      "runtime-instrument-id-execution"
+    ) / Compile / productDirectories).value ++
+    (LocalProject(
+      "runtime-instrument-repl-debugger"
+    ) / Compile / productDirectories).value ++
+    (LocalProject(
+      "runtime-instrument-runtime-server"
+    ) / Compile / productDirectories).value ++
+    (LocalProject(
+      "runtime-language-epb"
+    ) / Compile / productDirectories).value ++
+    (LocalProject("runtime-compiler") / Compile / productDirectories).value
+  val patchStr = modulesToPatchIntoRuntime
+    .map(_.getAbsolutePath)
+    .mkString(File.pathSeparator)
+  val allModulesPaths: Seq[String] =
+    runtimeMod.map(_.getAbsolutePath) ++
+    graalMods.map(_.data.getAbsolutePath) ++
+    loggingMods.map(_.getAbsolutePath)
+  // We can't use org.enso.logger.TestLogProvider (or anything from our own logging framework here) because it is not
+  // in a module, and it cannot be simple wrapped inside a module.
+  // So we use plain ch.qos.logback with its configuration.
+  val testLogbackConf = (LocalProject(
+    "logging-service-logback"
+  ) / Test / sourceDirectory).value / "resources" / "logback-test.xml"
+  Seq(
+    "-Dslf4j.provider=ch.qos.logback.classic.spi.LogbackServiceProvider",
+    s"-Dlogback.configurationFile=${testLogbackConf.getAbsolutePath}",
+    "--module-path",
+    allModulesPaths.mkString(File.pathSeparator),
+    "--add-modules",
+    runtimeModName,
+    "--patch-module",
+    s"$runtimeModName=$patchStr",
+    "--add-reads",
+    s"$runtimeModName=ALL-UNNAMED"
+  )
+}
+
 // ============================================================================
 // === Internal Libraries =====================================================
 // ============================================================================
@@ -1263,15 +1365,26 @@ lazy val `language-server` = (project in file("engine/language-server"))
   .settings(
     // These settings are needed by language-server tests that create a runtime context.
     Test / fork := true,
-    Test / javaOptions ++= testLogProviderOptions ++ Seq(
-      "-Dpolyglot.engine.WarnInterpreterOnly=false",
-      "-Dpolyglotimpl.DisableClassPathIsolation=true"
-    ),
-    // Append enso language on the class-path
-    Test / unmanagedClasspath :=
-      (LocalProject(
+    Test / javaOptions ++= testLogProviderOptions ++ {
+      val runtimeJar = (LocalProject(
         "runtime-with-instruments"
-      ) / Compile / fullClasspath).value,
+      ) / assembly / assemblyOutputPath).value
+      val log = streams.value.log
+      val requiredModules =
+        (Test / internalDependencyClasspath).value ++ (Test / unmanagedClasspath).value
+      val allModules = requiredModules.map(_.data.getAbsolutePath) ++ Seq(
+        runtimeJar.getAbsolutePath
+      )
+      Seq(
+        "--module-path",
+        allModules.mkString(File.pathSeparator),
+        "--add-modules",
+        // TODO: Use JPMSModule name
+        "org.enso.runtime"
+      )
+    },
+    // Append enso language on the class-path
+    Test / unmanagedClasspath := componentModulesPaths.value,
     Test / compile := (Test / compile)
       .dependsOn(LocalProject("enso") / updateLibraryManifests)
       .value,
@@ -1419,7 +1532,8 @@ lazy val runtime = (project in file("engine/runtime"))
       "junit"                % "junit"                   % junitVersion              % Test,
       "com.github.sbt"       % "junit-interface"         % junitIfVersion            % Test,
       "org.hamcrest"         % "hamcrest-all"            % hamcrestVersion           % Test,
-      "org.slf4j"            % "slf4j-nop"               % slf4jVersion              % Benchmark
+      "org.slf4j"            % "slf4j-nop"               % slf4jVersion              % Benchmark,
+      "org.slf4j"            % "slf4j-api"               % slf4jVersion              % Test
     ),
     // Add all GraalVM packages with Runtime scope - we don't need them for compilation,
     // just provide them at runtime (in module-path).
@@ -1432,9 +1546,10 @@ lazy val runtime = (project in file("engine/runtime"))
         GraalVM.toolsPkgs.map(_.withConfigurations(Some(Runtime.name)))
       necessaryModules ++ langs ++ tools
     },
-    Test / javaOptions ++= testLogProviderOptions ++ Seq(
-      "-Dpolyglotimpl.DisableClassPathIsolation=true"
-    ),
+    Test / javaOptions := modulePathTestOptions.value,
+    Test / unmanagedClasspath := (LocalProject(
+      "runtime-with-instruments"
+    ) / Compile / exportedProducts).value,
     Test / fork := true,
     Test / envVars ++= distributionEnvironmentOverrides ++ Map(
       "ENSO_TEST_DISABLE_IR_CACHE" -> "false"

lib/scala/logging-service-logback/src/test/resources/logback-test.xml

@@ -0,0 +1,19 @@
+<configuration>
+
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <!-- encoders are assigned the type
+         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+    <encoder>
+      <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%logger{36}] -%kvp- %msg%n</pattern>
+    </encoder>
+    <!-- deny all events with a level below WARN, that is INFO, DEBUG and TRACE -->
+    <!-- Accepts only WARN and ERROR -->
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+  </appender>
+
+  <root level="debug">
+    <appender-ref ref="STDOUT" />
+  </root>
+</configuration>

project/JPMSUtils.scala

@@ -1,21 +1,12 @@
 import sbt.*
 import sbt.Keys.*
-import sbtassembly.Assembly.{Dependency, JarEntry, Library, Project}
-import sbtassembly.MergeStrategy
-
-import java.io.{File, FilenameFilter}
-import sbtassembly.CustomMergeStrategy
-import xsbti.compile.IncToolOptionsUtil
 import sbt.internal.inc.{CompileOutput, PlainVirtualFile}
+import sbtassembly.Assembly.{Dependency, JarEntry, Project}
+import sbtassembly.{CustomMergeStrategy, MergeStrategy}
+import xsbti.compile.IncToolOptionsUtil
 
-import java.nio.file.attribute.BasicFileAttributes
-import java.nio.file.{
-  FileVisitResult,
-  FileVisitor,
-  Files,
-  Path,
-  SimpleFileVisitor
-}
+import java.io.File
+import java.nio.file.{Files, Path}
 
 /** Collection of utility methods dealing with JPMS modules.
   * The motivation comes from the update of GraalVM to
@@ -73,6 +64,41 @@ object JPMSUtils {
     ret
   }
 
+  /** Filters all the requested modules from the given [[UpdateReport]].
+    *
+    * @param updateReport     The update report to filter. This is the result of `update.value`.
+    * @param modules          The modules to filter from the update report.
+    * @param log              The logger to use for logging.
+    * @param shouldContainAll If true, the method will log an error if not all modules were found.
+    * @return The list of files (Jar archives, directories, etc.) that were found in the update report.
+    */
+  def filterModulesFromUpdate(
+    updateReport: UpdateReport,
+    modules: Seq[ModuleID],
+    log: sbt.util.Logger,
+    shouldContainAll: Boolean = false
+  ): Seq[File] = {
+    def shouldFilterModule(module: ModuleID): Boolean = {
+      modules.exists(m =>
+        m.organization == module.organization &&
+        m.name == module.name &&
+        m.revision == module.revision
+      )
+    }
+
+    val foundFiles = updateReport.select(
+      module = shouldFilterModule
+    )
+    if (shouldContainAll) {
+      if (foundFiles.size < modules.size) {
+        log.error("Not all modules from update were found")
+        log.error(s"Returned (${foundFiles.size}): $foundFiles")
+        log.error(s"Expected: (${modules.size}): $modules")
+      }
+    }
+    foundFiles
+  }
+
   def filterTruffleAndGraalArtifacts(
     classPath: Def.Classpath
   ): Def.Classpath = {