Merge pull request #652 from dwijnand/int-test-scala3-library

Author: dwijnand

RELEASING.md

@@ -10,7 +10,7 @@ See the [prerequisites](#prerequisites) if this is your first release.
 
 ## Release checklist
 
-* [ ] [Check Travis CI][travis-ci] passes against the latest Scala versions.
+* [ ] [Check CI][ci] passes against the latest Scala versions.
 * [ ] [Create a new milestone][milestones/new] for the release you are about to perform, if one [doesn't exist][milestones/list].
 * [ ] [Draft a new release][releases/new] for the release, by [comparing changes][compare/view].
 * [ ] Bump the version in the `README.md` and `git commit -am 'Release 0.x.y`.
@@ -43,14 +43,14 @@ See the [prerequisites](#prerequisites) if this is your first release.
 [repo1/list]: https://repo1.maven.org/maven2/com/typesafe/mima-core_2.12/0.5.0/
 [sonatype/guide]: https://central.sonatype.org/pages/releasing-the-deployment.html
 [sonatype/staging-repos]: https://oss.sonatype.org/#stagingRepositories
-[travis-ci]: https://travis-ci.com/github/lightbend/mima
+[ci]: https://github.com/lightbend/mima/actions/workflows/ci.yml
 
 You are done!
 
 ## Prerequisites
 
 * repo push rights
-* publishing crendentials for Sonatype, typically in `~/.sbt/1.0/credentials.sbt`:
+* publishing credentials for Sonatype, typically in `~/.sbt/1.0/credentials.sbt`:
 
 ```scala
     credentials += Credentials("Sonatype Nexus Repository Manager", "oss.sonatype.org", <username>, <password>)

build.sbt

@@ -81,8 +81,8 @@ val functionalTests = Project("functional-tests", file("functional-tests"))
     // ^ disabled b/c of "Build triggered by [..]/target/scala-2.12/v2-classes."
     testFunctional := (Test / test).value,
     Defaults.itSettings,
-               Test / mainClass := Some("com.typesafe.tools.mima.lib.UnitTests"),
-    IntegrationTest / mainClass := Some("com.typesafe.tools.mima.lib.IntegrationTests"),
+    Test / mainClass := Some("com.typesafe.tools.mima.lib.UnitTests"),
+    IntegrationTest / testOptions += Tests.Argument(TestFrameworks.MUnit, "-b"), // disable buffering => immediate output
     mimaFailOnNoPrevious := false,
     publish / skip := true,
   )

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

@@ -1,9 +1,27 @@
 package com.typesafe.tools.mima.lib
 
-import munit._
+import scala.reflect.io.Directory
 
-class IntegrationTestSuite extends Suite {
-  type TestValue = Unit
+import IntegrationTests._
 
-  def munitTests() = IntegrationTests.munitTests
+class IntegrationTestSuite extends munit.FunSuite {
+  itTest("scala-library-2-10")
+  itTest("scala-library-2-11")
+  itTest("scala-library-2-12")
+  itTest("scala-library-2-13")
+
+  itTest("scala-reflect-2-10")
+  itTest("scala-reflect-2-11")
+  itTest("scala-reflect-2-12")
+  itTest("scala-reflect-2-13")
+
+  itTest("java-9-module-info")
+
+  test("scala3-library")(testIntegration("org.scala-lang", "scala3-library_3", "3.0.0", "3.0.1")(
+    excludeAnnots = List("scala.annotation.experimental"),
+  ))
+
+  def itTest(name: String)(implicit loc: munit.Location) = test(name) {
+    testIntegrationDir(Directory(s"functional-tests/src/it/$name")).get
+  }
 }

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

@@ -3,29 +3,30 @@ package com.typesafe.tools.mima.lib
 import java.io.File
 import java.nio.file.Files
 
-import com.typesafe.tools.mima.core.Problem
+import com.typesafe.tools.mima.core.ProblemFilter
 
 import scala.collection.JavaConverters._
 import scala.util.{ Failure, Success, Try }
 
 object CollectProblemsTest {
   def testCollectProblems(testCase: TestCase, direction: Direction): Try[Unit] = for {
     () <- testCase.compileBoth
-    problems = collectProblems(cp = Nil, testCase.outV1.jfile, testCase.outV2.jfile, direction)
+    (v1, v2) = direction.ordered(testCase.outV1, testCase.outV2)
     expected = readOracleFile(testCase.versionedFile(direction.oracleFile).jfile)
-    () <- diffProblems(problems, expected, direction)
+    () <- collectAndDiff(cp = Nil, v1.jfile, v2.jfile)(
+      expected,
+      excludeAnnots = excludeAnnots,
+      direction     = direction,
+    )
   } yield ()
 
-  def collectProblems(cp: Seq[File], v1: File, v2: File, direction: Direction): List[Problem] = {
-    val (lhs, rhs) = direction.ordered(v1, v2)
-    new MiMaLib(cp).collectProblems(lhs, rhs, excludeAnnots)
-  }
-
-  def readOracleFile(oracleFile: File): List[String] = {
-    Files.lines(oracleFile.toPath).iterator.asScala.filter(!_.startsWith("#")).toList
-  }
-
-  def diffProblems(problems: List[Problem], expected: List[String], direction: Direction): Try[Unit] = {
+  def collectAndDiff(cp: Seq[File], v1: File, v2: File)(
+      expected: List[String]       = Nil,
+      problemFilter: ProblemFilter = _ => true,
+      excludeAnnots: List[String]  = Nil,
+      direction: Direction         = Backwards,
+  ): Try[Unit] = {
+    val problems = new MiMaLib(cp).collectProblems(v1, v2, excludeAnnots).filter(problemFilter)
     val affectedVersion = direction match {
       case Backwards => "new"
       case Forwards  => "other"
@@ -52,5 +53,9 @@ object CollectProblemsTest {
     }
   }
 
+  def readOracleFile(oracleFile: File): List[String] = {
+    Files.lines(oracleFile.toPath).iterator.asScala.filter(!_.startsWith("#")).toList
+  }
+
   private val excludeAnnots = List("mima.annotation.exclude")
 }

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

@@ -7,78 +7,62 @@ import scala.reflect.io.Directory
 import scala.util.{ Failure, Success, Try }
 
 import com.typesafe.config.ConfigFactory
-import com.typesafe.tools.mima.core.{ Problem, ProblemFilters }
+import com.typesafe.tools.mima.core.{ ProblemFilter, ProblemFilters }
 import coursier._
-import munit.GenericTest
 
-object IntegrationTests {
-  def main(args: Array[String]): Unit       = fromArgs(args.toList).unsafeRunTest()
-  def munitTests(): List[GenericTest[Unit]] = fromArgs(Nil).munitTests
+import CollectProblemsTest._, IntegrationTests._
 
-  def fromArgs(args: List[String]): Tests = {
-    val dirs = Directory("functional-tests/src/it").dirs.filter(args match {
-      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))))
+object IntegrationTests {
+  def testIntegrationDir(baseDir: Directory): Try[Unit] = {
+    val conf = ConfigFactory.parseFile((baseDir / "test.conf").jfile)
+      .withFallback(ConfigFactory.parseString("filter.problems = []"))
+      .resolve()
+    val problemFilter = conf.getConfigList("filter.problems").asScala.map { conf =>
+      ProblemFilters.exclude(conf.getString("problemName"), conf.getString("matchName"))
+    }.foldAll
+    val direction = Backwards
+    testIntegration(
+      conf.getString("groupId"),
+      conf.getString("artifactId"),
+      conf.getString("v1"),
+      conf.getString("v2"),
+    )(readOracleFile((baseDir / direction.oracleFile).jfile), problemFilter)
   }
 
-  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")
+  def testIntegration(groupId: String, artifactId: String, v1: String, v2: String)(
+      expected: List[String]           = Nil,
+      problemFilter: ProblemFilter     = _ => true,
+      excludeAnnots: List[String]      = Nil,
+      moduleAttrs: Map[String, String] = Map.empty,
+  ) = {
+    val module = Module(Organization(groupId), ModuleName(artifactId), moduleAttrs)
     for {
-      (v1,  _) <- getArtifact(groupId, artifactId, conf.getString("v1"))
-      (v2, cp) <- getArtifact(groupId, artifactId, conf.getString("v2"))
-      problemFilter <- getProblemFilter(baseDir.jfile)
-      () <- testCollectProblems(baseDir, problemFilter, cp, v1, v2, Backwards)
-    //() <- testCollectProblems(baseDir, problemFilter, cp, v1, v2, Forwards)
+      (v1, _)  <- fetchArtifact(Dependency(module, v1))
+      (v2, cp) <- fetchArtifact(Dependency(module, v2))
+      ()       <- collectAndDiff(cp, v1, v2)(expected, problemFilter, excludeAnnots)
     } yield ()
   }
 
-  def getArtifact(groupId: String, artifactId: String, version: String): Try[(File, Seq[File])] = {
-    fetchArtifact(Dependency(Module(Organization(groupId), ModuleName(artifactId)), version))
-  }
-
   def fetchArtifact(dep: Dependency): Try[(File, Seq[File])] = {
     Coursier.fetch(dep) match {
-      case Nil               => Failure(sys.error(s"Could not resolve artifact: $dep"))
       case Seq(jar, cp @ _*) => Success((jar, cp))
+      case _                 => Failure(sys.error(s"Could not resolve artifact: $dep"))
     }
   }
 
-  def getProblemFilter(baseDir: File): Try[Problem => Boolean] = Try {
-    val configFile = new File(baseDir, "test.conf")
-    val configFallback = ConfigFactory.parseString("filter { problems = [] }")
-    val config = ConfigFactory.parseFile(configFile).withFallback(configFallback).resolve()
-    val filters = for (conf <- config.getConfigList("filter.problems").asScala)
-      yield ProblemFilters.exclude(conf.getString("problemName"), conf.getString("matchName"))
-    (p: Problem) => filters.forall(filter => filter(p))
-  }
-
-  def testCollectProblems(baseDir: Directory, problemFilter: Problem => Boolean, cp: Seq[File], v1: File, v2: File, direction: Direction): Try[Unit] = {
-    val problems = CollectProblemsTest.collectProblems(cp, v1, v2, direction).filter(problemFilter)
-    val expected = CollectProblemsTest.readOracleFile((baseDir / direction.oracleFile).jfile)
-    CollectProblemsTest.diffProblems(problems, expected, direction)
+  implicit class PredicatesOps[A](private val ps: Iterable[A => Boolean]) extends AnyVal {
+    def foldAll: A => Boolean = (x: A) => ps.forall(p => p(x))
+    def foldAny: A => Boolean = (x: A) => ps.exists(p => p(x))
   }
 }
 
 object CompareJars {
   def main(args: Array[String]): Unit = args.toList match {
-    case Seq(file) => runTry(compare(new File(file), new File(file), Nil))
-    case Seq(groupId, artifactId, version1, version2, attrStrs @ _*) =>
+    case Seq(file) =>
+      runTry(collectAndDiff(Nil, new File(file), new File(file))())
+    case Seq(groupId, artifactId, v1, v2, attrStrs @ _*) =>
       val attrs = attrStrs.map { s => val Array(k, v) = s.split('='); k -> v }.toMap
-      val module = Module(Organization(groupId), ModuleName(artifactId)).withAttributes(attrs)
-      runTry(for {
-        (v1, _)  <- IntegrationTests.fetchArtifact(Dependency(module, version1))
-        (v2, cp) <- IntegrationTests.fetchArtifact(Dependency(module, version2))
-        ()       <- compare(v1, v2, cp)
-      } yield ())
-  }
-
-  def compare(v1: File, v2: File, cp: Seq[File], direction: Direction = Backwards): Try[Unit] = {
-    val problems = CollectProblemsTest.collectProblems(cp, v1, v2, direction)
-    CollectProblemsTest.diffProblems(problems, Nil, direction)
+      runTry(testIntegration(groupId, artifactId, v1, v2)(moduleAttrs = attrs))
   }
 
   def runTry(tri: Try[Unit]) = tri match {

project/plugins.sbt

@@ -14,4 +14,3 @@ resolvers ++= (if (isStaging) List(stagingResolver) else Nil)
 addSbtPlugin("com.dwijnand"   % "sbt-dynver"      % "4.1.1")
 addSbtPlugin("com.github.sbt" % "sbt-pgp"         % "2.1.2")
 addSbtPlugin("com.typesafe"   % "sbt-mima-plugin" % "0.9.2")
-addSbtPlugin("com.dwijnand"   % "sbt-travisci"    % "1.2.0")