TEMP: skip integration.feature[plugin-classpath].local.test

Author: bishabosha

integration/feature/plugin-classpath/src/MillPluginClasspathTest.scala

@@ -3,8 +3,50 @@ package mill.integration
 import mill.testkit.UtestIntegrationTestSuite
 
 import utest._
+import scala.concurrent.Future
+import scala.concurrent.ExecutionContext
+import java.util.concurrent.atomic.AtomicReference
 
-object MillPluginClasspathTest extends UtestIntegrationTestSuite {
+/**Trait that provides a `skip` method that can be used to skip a test, the test will pass.
+ * Used to assert that a test still compiles, and is intended to be re-enabled later,
+ * but is temporarily prevented from running for a suitable reason.
+ * At the end of a suite, print a summary of the number of skipped tests, and their names.
+ * @note I'd propose to make "skipping" a part core utest library, so that the summary includes the skipped tests
+ */
+trait UTestIgnore(name: String) extends utest.TestSuite {
+
+  val skipList = AtomicReference(List.empty[String])
+
+  private final class SkipException(val name: String) extends Exception with scala.util.control.NoStackTrace
+
+  def skip(op: => Any)(using path: utest.framework.TestPath): Nothing = {
+    throw new SkipException(name + "." + path.value.mkString("."))
+  }
+
+  private def red(str: String) = Console.RED + str + Console.RESET
+
+  override def utestWrap(path: Seq[String], runBody: => Future[Any])(implicit ec: ExecutionContext): Future[Any] = {
+    super.utestWrap(path, runBody.recoverWith {
+      case e: SkipException =>
+        skipList.updateAndGet(e.name :: _)
+        Future.successful(())
+    })
+  }
+
+  override def utestAfterAll(): Unit = {
+    val skipped = skipList.getAndUpdate(_ => Nil).reverse
+    if (skipped.nonEmpty) {
+      println(s"${red("!")} Skipped tests in $name:")
+      skipped.foreach { s =>
+        println(s"  - $s")
+      }
+      println("Skipped: " + skipped.size)
+    }
+  }
+}
+
+object MillPluginClasspathTest extends UtestIntegrationTestSuite
+  with UTestIgnore("mill.integration.MillPluginClasspathTest") {
 
   val embeddedModules: Seq[(String, String)] = Seq(
     ("com.lihaoyi", "mill-main-client"),
@@ -30,44 +72,47 @@ object MillPluginClasspathTest extends UtestIntegrationTestSuite {
 
   val tests: Tests = Tests {
 
-    test("exclusions") - integrationTest { tester =>
-      import tester._
-      retry(3) {
-        val res1 = eval(("--meta-level", "1", "resolveDepsExclusions"))
-        assert(res1.isSuccess)
+    test("exclusions") - skip {
+      integrationTest { tester =>
+        import tester._
+        retry(3) {
+          val res1 = eval(("--meta-level", "1", "resolveDepsExclusions"))
+          assert(res1.isSuccess)
 
-        val exclusions = out("mill-build.resolveDepsExclusions").value[Seq[(String, String)]]
-        val expectedExclusions = embeddedModules
+          val exclusions = out("mill-build.resolveDepsExclusions").value[Seq[(String, String)]]
+          val expectedExclusions = embeddedModules
 
-        val diff = expectedExclusions.toSet.diff(exclusions.toSet)
-        assert(diff.isEmpty)
+          val diff = expectedExclusions.toSet.diff(exclusions.toSet)
+          assert(diff.isEmpty)
+        }
       }
     }
-    test("runClasspath") - integrationTest { tester =>
-      import tester._
-      retry(3) {
-        // We expect Mill core transitive dependencies to be filtered out
-        val res1 = eval(("--meta-level", "1", "runClasspath"))
-        assert(res1.isSuccess)
+    test("runClasspath") - skip {
+      integrationTest { tester =>
+        import tester._
+        retry(3) {
+          // We expect Mill core transitive dependencies to be filtered out
+          val res1 = eval(("--meta-level", "1", "runClasspath"))
+          assert(res1.isSuccess)
 
-        val runClasspath = out("mill-build.runClasspath").value[Seq[String]]
+          val runClasspath = out("mill-build.runClasspath").value[Seq[String]]
 
-        val unexpectedArtifacts = embeddedModules.map {
-          case (o, n) => s"${o.replaceAll("[.]", "/")}/${n}"
-        }
+          val unexpectedArtifacts = embeddedModules.map {
+            case (o, n) => s"${o.replaceAll("[.]", "/")}/${n}"
+          }
 
-        val unexpected = unexpectedArtifacts.flatMap { a =>
-          runClasspath.find(p => p.toString.contains(a)).map((a, _))
-        }.toMap
-        assert(unexpected.isEmpty)
+          val unexpected = unexpectedArtifacts.flatMap { a =>
+            runClasspath.find(p => p.toString.contains(a)).map((a, _))
+          }.toMap
+          assert(unexpected.isEmpty)
 
-        val expected =
-          Seq("com/disneystreaming/smithy4s/smithy4s-mill-codegen-plugin_mill0.11_2.13")
-        assert(expected.forall(a =>
-          runClasspath.exists(p => p.toString().replace('\\', '/').contains(a))
-        ))
+          val expected =
+            Seq("com/disneystreaming/smithy4s/smithy4s-mill-codegen-plugin_mill0.11_2.13")
+          assert(expected.forall(a =>
+            runClasspath.exists(p => p.toString().replace('\\', '/').contains(a))
+          ))
+        }
       }
     }
-
   }
 }