fixup! f96fe2e Don't consider frameworks used if we found no tests with them

Author: Jaden Peterson

src/main/scala/higherkindness/rules_scala/common/sbt-testing/Test.scala

@@ -13,7 +13,7 @@ object TestDefinition {
 }
 
 class TestFrameworkLoader(loader: ClassLoader) {
-  private val loadedJars = mutable.ArrayBuffer[Path]()
+  private val loadedJarsByFramework = mutable.Map.empty[String, mutable.ArrayBuffer[Path]]
   private def getClassJar(`class`: Class[?]): Option[Path] = for {
     codeSource <- Option(`class`.getProtectionDomain().getCodeSource())
     codeSourceUri = codeSource.getLocation().toURI()
@@ -25,22 +25,27 @@ class TestFrameworkLoader(loader: ClassLoader) {
       }
   } yield path
 
-  def getLoadedJars(): Array[Path] = loadedJars.toArray
+  def getLoadedJarsByFramework(): Map[String, Array[Path]] =
+    loadedJarsByFramework.view.map { case (frameworkName, loadedJars) => frameworkName -> loadedJars.toArray }.toMap
+
   def load(className: String) = {
-    val framework =
+    val (framework, loadedJar) =
       try {
         val `class` = Class.forName(className, true, loader)
+        val loadedJar = getClassJar(`class`)
 
-        getClassJar(`class`).foreach(loadedJars += _)
-
-        Some(`class`.getDeclaredConstructor().newInstance())
+        (Some(`class`.getDeclaredConstructor().newInstance()), loadedJar)
       } catch {
-        case _: ClassNotFoundException => None
+        case _: ClassNotFoundException => (None, None)
         case NonFatal(e)               => throw new Exception(s"Failed to load framework $className", e)
       }
     framework.map {
-      case framework: Framework => framework
-      case _                    => throw new Exception(s"$className does not implement ${classOf[Framework].getName}")
+      case framework: Framework =>
+        loadedJar.foreach(loadedJarsByFramework.getOrElseUpdate(className, mutable.ArrayBuffer.empty) += _)
+
+        framework
+
+      case _ => throw new Exception(s"$className does not implement ${classOf[Framework].getName}")
     }
 
   }

src/main/scala/higherkindness/rules_scala/workers/zinc/compile/ZincRunner.scala

@@ -225,9 +225,17 @@ object ZincRunner extends WorkerMain[Unit] {
             .toMap,
         )
 
+        val loadedJarsByFramework = frameworkLoader.getLoadedJarsByFramework()
+        val loadedJars = testsFileData.testsByFramework.view
+          .filter { case (_, tests) => tests.nonEmpty }
+          .keys
+          .flatMap(loadedJarsByFramework.get)
+          .flatten
+          .toArray
+
         Files.write(path, Json.stringify(Json.toJson(testsFileData)).getBytes(StandardCharsets.UTF_8))
 
-        frameworkLoader.getLoadedJars()
+        loadedJars
       }
       .getOrElse(Array.empty)
 
@@ -304,6 +312,15 @@ object ZincRunner extends WorkerMain[Unit] {
 
     InterruptUtil.throwIfInterrupted(task.isCancelled)
 
+    /*
+     * JARs on the classpath used during test discovery, but not used by compiler won't show up in `analysis.usedJars`, so
+     * we need to consider them in addition to those used by the compiler.
+     *
+     * Test discovery works by iterating through the list of test frameworks provided via `workRequest.testFrameworks`,
+     * attempting to classload each framework, and then using that framework to discover tests. If a given framework
+     * successfully loads and we found a test with it we take note of the JAR it was loaded from and consider that JAR
+     * (and therefore the target to which it belongs) used.
+     */
     val usedDepsDuringTestDiscovery = maybeWriteTestsFile(workRequest, analysis)
 
     InterruptUtil.throwIfInterrupted(task.isCancelled)