make it run junit too

Author: andyscott

WORKSPACE

@@ -62,6 +62,17 @@ scala_maven_import_external(
     ],
 )
 
+scala_maven_import_external(
+    name = "com_novocode_junit_interface",
+    artifact = "com.novocode:junit-interface:0.11",
+    artifact_sha256 = "29e923226a0d10e9142bbd81073ef52f601277001fcf9014389bf0af3dc33dc3",
+    licenses = ["notice"],  # Apache 2.0
+    server_urls = [
+        "https://repo1.maven.org/maven2/",
+        "https://mirror.bazel.build/repo1.maven.org/maven2",
+    ],
+)
+
 # test adding a scala jar:
 jvm_maven_import_external(
     name = "com_twitter__scalding_date",

scala/private/phases/phase_discover_tests.bzl

@@ -15,7 +15,7 @@ def phase_discover_tests(ctx, p):
     args.add(output)
     args.add_all(p.compile.full_jars)
     args.add("--")
-    args.add_all(p.collect_jars.compile_jars)
+    args.add_all(p.collect_jars.transitive_runtime_jars)
 
     ctx.actions.run(
         mnemonic = "DiscoverTests",

src/scala/io/bazel/rules_scala/discover_tests_runner/DiscoverTestsRunner.scala

@@ -4,8 +4,10 @@ import io.bazel.rules_scala.discover_tests_worker.DiscoveredTests.Result
 import io.bazel.rules_scala.discover_tests_worker.DiscoveredTests.FrameworkDiscovery
 import io.bazel.rules_scala.discover_tests_worker.DiscoveredTests.SubclassDiscovery
 
+import sbt.testing.AnnotatedFingerprint
 import sbt.testing.Event
 import sbt.testing.EventHandler
+import sbt.testing.Fingerprint
 import sbt.testing.Framework
 import sbt.testing.Logger
 import sbt.testing.Runner
@@ -38,24 +40,39 @@ object DiscoverTestsRunner {
     val framework: Framework = Class.forName(frameworkDiscovery.getFramework).newInstance.asInstanceOf[Framework]
     val runner: Runner = framework.runner(args, Array.empty, Thread.currentThread.getContextClassLoader)
 
-    val subclassFingerprintMap: Map[(String, Boolean, Boolean), SubclassFingerprint] = framework.fingerprints.collect {
-      case fingerprint: SubclassFingerprint => (fingerprint.superclassName, fingerprint.isModule, fingerprint.requireNoArgConstructor) -> fingerprint
-    }.toMap
+    val subclassFingerprintMap: Map[(String, Boolean, Boolean), SubclassFingerprint] =
+      framework.fingerprints.collect {
+        case fingerprint: SubclassFingerprint =>
+          (fingerprint.superclassName, fingerprint.isModule, fingerprint.requireNoArgConstructor) -> fingerprint
+      }.toMap
 
-    frameworkDiscovery.getSubclassDiscoveriesList
-      .asScala
+    val annotatedFingerprintMap: Map[(String, Boolean), AnnotatedFingerprint] =
+      framework.fingerprints.collect {
+        case fingerprint: AnnotatedFingerprint =>
+          (fingerprint.annotationName, fingerprint.isModule) -> fingerprint
+      }.toMap
+
+    frameworkDiscovery.getSubclassDiscoveriesList.asScala
       .foreach { subclassDiscovery =>
-        val fingerprint: SubclassFingerprint = subclassFingerprintMap.get((subclassDiscovery.getSuperclassName, subclassDiscovery.getIsModule, subclassDiscovery.getRequireNoArgConstructor))
+        val fingerprint = subclassFingerprintMap.get((subclassDiscovery.getSuperclassName, subclassDiscovery.getIsModule, subclassDiscovery.getRequireNoArgConstructor))
           .getOrElse(sys.error(s"Unable to resolve fingerprint instance for $subclassDiscovery"))
 
         handleTests(runner, fingerprint, subclassDiscovery.getTestsList.asScala.toList)
       }
 
+    frameworkDiscovery.getAnnotatedDiscoveriesList.asScala
+      .foreach { annotatedDiscovery =>
+        val fingerprint = annotatedFingerprintMap.get((annotatedDiscovery.getAnnotationName, annotatedDiscovery.getIsModule))
+          .getOrElse(sys.error(s"Unable to resolve fingerprint instance for $annotatedDiscovery"))
+
+        handleTests(runner, fingerprint, annotatedDiscovery.getTestsList.asScala.toList)
+      }
+
     println(runner.done())
     println(s"< run of ${frameworkDiscovery.getFramework} complete")
   }
 
-  def handleTests(runner: Runner, fingerprint: SubclassFingerprint, tests: List[String]): Unit = {
+  def handleTests(runner: Runner, fingerprint: Fingerprint, tests: List[String]): Unit = {
     val eventHandler: EventHandler = new EventHandler {
       def handle(event: Event): Unit = {
         //println(s"- $event")

src/scala/io/bazel/rules_scala/discover_tests_worker/DiscoverTestsWorker.scala

@@ -42,6 +42,7 @@ object DiscoverTestsWorker extends Worker.Interface {
       .ignoreParentClassLoaders
       .enableClassInfo
       .enableMethodInfo
+      .enableAnnotationInfo
       .scan
 
     val result: Result = frameworkScanResult
@@ -58,9 +59,11 @@ object DiscoverTestsWorker extends Worker.Interface {
                   else
                     _.getSubclasses(fingerprint.superclassName)
 
-              val candidates = getCandidates(testScanResult).exclude(getCandidates(frameworkScanResult))
-                .asScala
-                .filter(_.isStandardClass)
+              val candidates: Iterable[ClassInfo] =
+                getCandidates(testScanResult)
+                  .exclude(getCandidates(frameworkScanResult))
+                  .asScala
+                  .filter(_.isStandardClass)
 
               val tests: Iterable[String] =
                 if (fingerprint.isModule)
@@ -81,17 +84,34 @@ object DiscoverTestsWorker extends Worker.Interface {
                   .addAllTests(tests.asJava)
                   .build)
             case fingerprint: AnnotatedFingerprint =>
+
+              val candidates: Iterable[ClassInfo] =
+                testScanResult.getClassesWithAnnotation(fingerprint.annotationName)
+                  .union(testScanResult.getClassesWithMethodAnnotation(fingerprint.annotationName))
+                  .asScala
+
+              val tests: Iterable[String] =
+                if (fingerprint.isModule)
+                  candidates
+                    .map(_.getName)
+                    .filter(_.endsWith("$")).map(_.dropRight(1))
+                else
+                  candidates
+                    .map(_.getName)
+                    .filterNot(_.endsWith("$"))
+
               b.addAnnotatedDiscoveries(
                 AnnotatedDiscovery.newBuilder
+                  .setAnnotationName(fingerprint.annotationName)
+                  .setIsModule(fingerprint.isModule)
+                  .addAllTests(tests.asJava)
                   .build)
           }).build)
       }.build
 
     testScanResult.close()
     frameworkScanResult.close()
 
-    //println(result)
-
     val os = new FileOutputStream(outputFile)
     result.writeTo(os)
     os.close()

src/scala/io/bazel/rules_scala/discover_tests_worker/discovered_tests.proto

@@ -22,5 +22,7 @@ message SubclassDiscovery {
 }
 
 message AnnotatedDiscovery {
-  string empty = 1;
+  string annotationName = 1;
+  bool isModule = 2;
+  repeated string tests = 3;
 }

test/v2/BUILD

@@ -24,11 +24,15 @@ scala_test(
     deps = [
         ":library",
 	"@org_scalacheck_scalacheck//:org_scalacheck_scalacheck",
+        "@io_bazel_rules_scala_junit_junit//:io_bazel_rules_scala_junit_junit",
         "//external:io_bazel_rules_scala/dependency/scalatest/scalatest",
     ],
     runtime_deps = [
+        "@com_novocode_junit_interface//:com_novocode_junit_interface",
         # this would normally get exported by scalatest if it was set up as a proper dep
 	# instead of just a jar
 	"//external:io_bazel_rules_scala/dependency/scala/scala_xml",
+        # same, but for junit
+        "@io_bazel_rules_scala_org_hamcrest_hamcrest_core//:io_bazel_rules_scala_org_hamcrest_hamcrest_core",
     ]
 )

test/v2/test.scala

@@ -5,6 +5,9 @@ import org.scalatest.FunSuite
 import org.scalacheck.Properties
 import org.scalacheck.Prop._
 
+import org.junit.Test
+import org.junit.Assert.assertEquals
+
 final class TestSuiteClass extends FunSuite {
   test("method1") {
     assert(Library.method1 == "hello")
@@ -28,3 +31,10 @@ final class TestPropertiesClass extends Properties("TestPropertiesClass") {
 object TestPropertiesObject extends Properties("TestPropertiesObject") {
   property("2") = 2 ?= 2
 }
+
+final class JUnitTest {
+  @Test
+  def testFoo(): Unit = {
+    assertEquals("Test should pass", true, true)
+  }
+}