Merge pull request #526 from dwijnand/munit

Author: dwijnand

build.sbt

@@ -63,11 +63,16 @@ val sbtplugin = project.enablePlugins(SbtPlugin).dependsOn(core).settings(
 val testFunctional = taskKey[Unit]("Run the functional test")
 val functionalTests = Project("functional-tests", file("functional-tests"))
   .dependsOn(core)
+  .configs(IntegrationTest)
   .settings(
     libraryDependencies += "com.typesafe" % "config" % "1.4.0",
     libraryDependencies += "io.get-coursier" %% "coursier" % "2.0.0-RC6-25",
-    testFunctional := (Compile / runMain).toTask(" com.typesafe.tools.mima.lib.UnitTests").value,
-    IntegrationTest / test := (Compile / runMain).toTask(" com.typesafe.tools.mima.lib.IntegrationTests").value,
+    libraryDependencies += "org.scalameta" %% "munit" % "0.7.9" % s"$Test;$IntegrationTest",
+    testFrameworks += new TestFramework("munit.Framework"),
+    //Test / run / fork := true,
+    //Test / run / forkOptions := (Test / run / forkOptions).value.withWorkingDirectory((ThisBuild / baseDirectory).value),
+    testFunctional := (Test / test).value,
+    Defaults.itSettings,
     mimaFailOnNoPrevious := false,
     skip in publish := true,
   )

functional-tests/src/it/scala/IntegrationTestSuite.scala

@@ -0,0 +1,11 @@
+package com.typesafe.tools.mima.lib
+
+import munit._
+
+class IntegrationTestSuite extends Suite {
+  type TestValue = Unit
+
+  def munitTests() = for {
+    test <- IntegrationTests.fromArgs(Nil).tests
+  } yield new GenericTest(test.label, test.action, Set.empty, Location.empty)
+}

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/AppRunTest.scala

@@ -9,7 +9,7 @@ import scala.util.{ Failure, Success, Try }
 
 /** Test running the App, using library v2. */
 object AppRunTest {
-  def main(args: Array[String]): Unit = TestCase.testAll(args.toList)(testAppRun)
+  def main(args: Array[String]): Unit = TestCase.argsToTests(args.toList, testAppRun).assert()
 
   def testAppRun(testCase: TestCase) = {
     import testCase._

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/CollectProblemsTest.scala

@@ -10,7 +10,7 @@ import scala.collection.JavaConverters._
 import scala.util.{ Failure, Success, Try }
 
 object CollectProblemsTest {
-  def main(args: Array[String]): Unit = TestCase.testAll(args.toList)(testCollectProblems)
+  def main(args: Array[String]): Unit = TestCase.argsToTests(args.toList, testCollectProblems).assert()
 
   def testCollectProblems(testCase: TestCase) = {
     import testCase._

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/IntegrationTests.scala

@@ -8,15 +8,17 @@ import scala.reflect.io.Directory
 import scala.util.Try
 
 object IntegrationTests {
-  def main(args: Array[String]): Unit = {
+  def main(args: Array[String]): Unit = fromArgs(args.toList).assert()
+
+  def fromArgs(args: List[String]): Tests = {
     val dirs = Directory("functional-tests/src/it").dirs.filter(args match {
-      case Array() => dir => dir.files.exists(_.name == "test.conf")
-      case xs      => xs.toSet.compose(_.name)
-    }).toSeq.sortBy(_.path)
-    TestPrinter.testAll(dirs)(dir => s"${dir.name}")(testIntegration)
+      case Seq() => dir => dir.files.exists(_.name == "test.conf")
+      case names => dir => names.contains(dir.name)
+    }).toList.sortBy(_.path)
+    Tests(dirs.map(dir => Test(dir.name, testIntegration(dir))))
   }
 
-  def testIntegration(baseDir: Directory) = {
+  def testIntegration(baseDir: Directory): Try[Unit] = {
     val conf       = ConfigFactory.parseFile((baseDir / "test.conf").jfile).resolve()
     val groupId    = conf.getString("groupId")
     val artifactId = conf.getString("artifactId")

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/Test.scala

@@ -0,0 +1,48 @@
+package com.typesafe.tools.mima.lib
+
+import scala.util.{ Failure, Success, Try }
+
+object Test {
+  def apply(label: String, action: => Unit): Test1 = Test1(label, () => action)
+
+  def pass = s"${Console.GREEN}\u2713${Console.RESET}" // check mark (green)
+  def fail = s"${Console.RED}\u2717${Console.RESET}"   // cross mark (red)
+
+  def testAll(tests: List[Test]): Try[Unit] = {
+    tests.iterator.map(_.run()).foldLeft(Try(())) {
+      case (res @ Failure(e1), Failure(e2)) => e1.addSuppressed(e2); res
+      case (res @ Failure(_), _)            => res
+      case (res, _)                         => res
+    }
+  }
+
+  def run1(label: String, action: () => Unit): Try[Unit] = {
+    Try(action()) match {
+      case res @ Success(()) => println(s"+ $pass  $label"); res
+      case res @ Failure(ex) => println(s"- $fail  $label: $ex"); res
+    }
+  }
+
+  if (System.out != Console.out) {
+    System.out.println(" System.out identity ##: " + System.identityHashCode(System.out))
+    System.out.println("Console.out identity ##: " + System.identityHashCode(scala.Console.out))
+    System.out.println("cwd: " + new java.io.File("").getAbsoluteFile)
+  }
+}
+
+sealed trait Test {
+  def assert(): Unit   = run().get
+
+  def run(): Try[Unit] = this match {
+    case Test1(l, a) => Test.run1(l, a)
+    case Tests(ts)   => Test.testAll(ts)
+  }
+
+  override def toString = this match {
+    case Test1(l, _)  => s"Test($l)"
+    case Tests(tests) => s"Tests(${tests.mkString(", ")})"
+  }
+}
+
+case class Test1(label: String, action: () => Unit) extends Test
+case class Tests(tests: List[Test1]) extends Test

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/TestCase.scala

@@ -18,31 +18,42 @@ object TestCase {
   val scala213 = "2.13.2"
   val hostScalaVersion = scala.util.Properties.versionNumberString
 
-  def testAll(argv: List[String])(test: TestCase => Try[Unit]): Unit =
-    TestPrinter.testAll(fromArgs(argv))(tc => s"${tc.scalaBinaryVersion} / ${tc.name}")(test)
+  def argsToTests(argv: List[String], runTestCase: TestCase => Try[Unit]): Tests =
+    Tests(fromArgs(argv).map(tc => Test(s"${tc.scalaBinaryVersion} / ${tc.name}", runTestCase(tc))))
 
   def fromArgs(argv: List[String]): List[TestCase] = {
     val Conf(svs, dirs0) = go(argv, Conf(Nil, Nil))
-    val dirs = if (dirs0.nonEmpty) dirs0 else
+    val dirs = if (dirs0.nonEmpty) dirs0.reverse else
       Directory("functional-tests/src/test").dirs
         .filter(_.files.exists(_.name == "problems.txt"))
         .toSeq.sortBy(_.path)
-    val scalaCompilers = (if (svs.isEmpty) List(hostScalaVersion) else svs).map(new ScalaCompiler(_))
+    val scalaCompilers = (if (svs.isEmpty) List(hostScalaVersion) else svs.reverse).map(new ScalaCompiler(_))
     val javaCompiler = ToolProvider.getSystemJavaCompiler
     for (sc <- scalaCompilers; dir <- dirs) yield new TestCase(dir, sc, javaCompiler)
   }
 
   final case class Conf(scalaVersions: List[String], dirs: List[Directory])
 
   @tailrec private def go(argv: List[String], conf: Conf): Conf = argv match {
-    case "-213" :: xs                  => go(xs, conf.copy(scalaVersions = conf.scalaVersions :+ scala213))
-    case "-212" :: xs                  => go(xs, conf.copy(scalaVersions = conf.scalaVersions :+ scala212))
-    case "-211" :: xs                  => go(xs, conf.copy(scalaVersions = conf.scalaVersions :+ scala211))
-    case "--scala-version" :: sv :: xs => go(xs, conf.copy(scalaVersions = conf.scalaVersions :+ sv))
-    case "--cross" :: xs               => go(xs, conf.copy(scalaVersions = List(scala213, scala212, scala211)))
-    case s :: xs                       => go(xs, conf.copy(dirs = conf.dirs :+ Directory(s"functional-tests/src/test/$s")))
+    case "-213" :: xs                  => go(xs, conf.copy(scalaVersions = scala213 :: conf.scalaVersions))
+    case "-212" :: xs                  => go(xs, conf.copy(scalaVersions = scala212 :: conf.scalaVersions))
+    case "-211" :: xs                  => go(xs, conf.copy(scalaVersions = scala211 :: conf.scalaVersions))
+    case "--scala-version" :: sv :: xs => go(xs, conf.copy(scalaVersions = sv :: conf.scalaVersions))
+    case "--cross" :: xs               => go(xs, conf.copy(scalaVersions = List(scala211, scala212, scala213)))
+    case s :: xs                       => go(xs, conf.copy(dirs = testDir(s) ::: conf.dirs))
     case Nil                           => conf
   }
+
+  def testDir(s: String) = {
+    val base = Directory("functional-tests/src/test")
+    base.dirs.find(_.name == s) match {
+      case Some(d) => List(d)
+      case _       => base.dirs.filter(_.name.contains(s)).toList.sortBy(_.path) match {
+        case Nil  => sys.error(s"No such directory: ${base / s}")
+        case dirs => dirs
+      }
+    }
+  }
 }
 
 final class TestCase(val baseDir: Directory, val scalaCompiler: ScalaCompiler, val javaCompiler: JavaCompiler) {
@@ -110,4 +121,6 @@ final class TestCase(val baseDir: Directory, val scalaCompiler: ScalaCompiler, v
       case _      => p
     }
   }
+
+  override def toString = s"TestCase(baseDir=${baseDir.name}, scalaVersion=${scalaCompiler.version})"
 }

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/TestPrinter.scala

@@ -4,15 +4,13 @@ import scala.reflect.io.Path
 import scala.util.{ Failure, Success, Try }
 
 object UnitTests {
-  def main(args: Array[String]): Unit = {
-    TestCase.testAll(args.toList) { testCase =>
-      for {
-        () <- testNameCheck(testCase)
-        () <- CollectProblemsTest.testCollectProblems(testCase)
-        () <- AppRunTest.testAppRun(testCase)
-      } yield ()
-    }
-  }
+  def main(args: Array[String]): Unit = TestCase.argsToTests(args.toList, runTestCase).assert()
+
+  def runTestCase(testCase: TestCase) = for {
+    () <- testNameCheck(testCase)
+    () <- CollectProblemsTest.testCollectProblems(testCase)
+    () <- AppRunTest.testAppRun(testCase)
+  } yield ()
 
   def testNameCheck(testCase: TestCase): Try[Unit] = {
     val emptyProblemsTxt = blankFile(testCase.baseDir / "problems.txt")

functional-tests/src/main/scala/com/typesafe/tools/mima/lib/UnitTests.scala

@@ -0,0 +1,11 @@
+package com.typesafe.tools.mima.lib
+
+import munit._
+
+class UnitTestSuite extends Suite {
+  type TestValue = Unit
+
+  def munitTests() = for {
+    test <- TestCase.argsToTests(Nil, UnitTests.runTestCase).tests
+  } yield new GenericTest(test.label, test.action, Set.empty, Location.empty)
+}