NIT Refactor existing --watch tests

Gedochao · Gedochao · commit ecee1513cc9d · 2024-09-13T11:15:26.000+02:00
diff --git a/modules/integration/src/test/scala/scala/cli/integration/RunTestDefinitions.scala b/modules/integration/src/test/scala/scala/cli/integration/RunTestDefinitions.scala
@@ -6,8 +6,7 @@ import java.io.{ByteArrayOutputStream, File}
 import java.nio.charset.Charset
 
 import scala.cli.integration.util.DockerServer
-import scala.concurrent.ExecutionContext
-import scala.concurrent.duration.Duration
+import scala.concurrent.duration.DurationInt
 import scala.io.Codec
 import scala.jdk.CollectionConverters.*
 import scala.util.Properties
@@ -1509,14 +1508,12 @@ abstract class RunTestDefinitions
 
   test("watch with interactive, with multiple main classes") {
     val fileName = "watch.scala"
-
-    val inputs = TestInputs(
+    TestInputs(
       os.rel / fileName ->
         """object Run1 extends App {println("Run1 launched")}
           |object Run2 extends App {println("Run2 launched")}
           |""".stripMargin
-    )
-    inputs.fromRoot { root =>
+    ).fromRoot { root =>
       val confDir  = root / "config"
       val confFile = confDir / "test-config.json"
 
@@ -1527,76 +1524,66 @@ abstract class RunTestDefinitions
 
       val configEnv = Map("SCALA_CLI_CONFIG" -> confFile.toString)
 
-      val proc = os.proc(TestUtil.cli, "run", "--watch", "--interactive", fileName)
-        .spawn(
-          cwd = root,
-          mergeErrIntoOut = true,
-          stdout = os.Pipe,
-          stdin = os.Pipe,
-          env = Map("SCALA_CLI_INTERACTIVE" -> "true") ++ configEnv
-        )
-
-      try
-        TestUtil.withThreadPool("run-watch-interactive-multi-main-class-test", 2) { pool =>
-          val timeout     = Duration("60 seconds")
-          implicit val ec = ExecutionContext.fromExecutorService(pool)
-
-          def lineReaderIter = Iterator.continually {
-            val line = TestUtil.readLine(proc.stdout, ec, timeout)
-            println(s"Line read: $line")
-            line
-          }
+      TestUtil.withProcessWatching(
+        proc = os.proc(TestUtil.cli, "run", "--watch", "--interactive", fileName)
+          .spawn(
+            cwd = root,
+            mergeErrIntoOut = true,
+            stdout = os.Pipe,
+            stdin = os.Pipe,
+            env = Map("SCALA_CLI_INTERACTIVE" -> "true") ++ configEnv
+          ),
+        timeout = 60.seconds
+      ) { (proc, timeout, ec) =>
+        def lineReaderIter: Iterator[String] = Iterator.continually {
+          val line = TestUtil.readLine(proc.stdout, ec, timeout)
+          println(s"Line read: $line")
+          line
+        }
 
-          def checkLinesForError(lines: Seq[String]) = munit.Assertions.assert(
-            !lines.exists { line =>
-              TestUtil.removeAnsiColors(line).contains("[error]")
-            },
-            clues(lines.toSeq)
-          )
+        def checkLinesForError(lines: Seq[String]): Unit = munit.Assertions.assert(
+          !lines.exists { line =>
+            TestUtil.removeAnsiColors(line).contains("[error]")
+          },
+          clues(lines.toSeq)
+        )
 
-          def answerInteractivePrompt(id: Int) = {
-            val interactivePromptLines = lineReaderIter
-              .takeWhile(!_.startsWith("[1]" /* probably [1] Run2  or [1] No*/ ))
-              .toList
-            expect(interactivePromptLines.nonEmpty)
-            checkLinesForError(interactivePromptLines)
-            proc.stdin.write(s"$id\n")
-            proc.stdin.flush()
-          }
+        def answerInteractivePrompt(id: Int): Unit = {
+          val interactivePromptLines = lineReaderIter
+            .takeWhile(!_.startsWith("[1]" /* probably [1] Run2  or [1] No*/ ))
+            .toList
+          expect(interactivePromptLines.nonEmpty)
+          checkLinesForError(interactivePromptLines)
+          proc.stdin.write(s"$id\n")
+          proc.stdin.flush()
+        }
 
-          def analyzeRunOutput(restart: Boolean) = {
-            val runResultLines = lineReaderIter
-              .takeWhile(!_.contains("press Enter to re-run"))
-              .toList
-            expect(runResultLines.nonEmpty)
-            checkLinesForError(runResultLines)
-            if (restart)
-              proc.stdin.write("\n")
-            proc.stdin.flush()
-          }
+        def analyzeRunOutput(restart: Boolean): Unit = {
+          val runResultLines = lineReaderIter
+            .takeWhile(!_.contains("press Enter to re-run"))
+            .toList
+          expect(runResultLines.nonEmpty)
+          checkLinesForError(runResultLines)
+          if (restart)
+            proc.stdin.write("\n")
+          proc.stdin.flush()
+        }
 
-          // You have run the current scala-cli command with the --interactive mode turned on.
-          // Would you like to leave it on permanently?
-          answerInteractivePrompt(0)
+        // You have run the current scala-cli command with the --interactive mode turned on.
+        // Would you like to leave it on permanently?
+        answerInteractivePrompt(0)
 
-          // Found several main classes. Which would you like to run?
-          answerInteractivePrompt(0)
-          expect(TestUtil.readLine(proc.stdout, ec, timeout) == "Run1 launched")
+        // Found several main classes. Which would you like to run?
+        answerInteractivePrompt(0)
+        expect(TestUtil.readLine(proc.stdout, ec, timeout) == "Run1 launched")
 
-          analyzeRunOutput( /* restart */ true)
+        analyzeRunOutput( /* restart */ true)
 
-          answerInteractivePrompt(1)
-          expect(TestUtil.readLine(proc.stdout, ec, timeout) == "Run2 launched")
+        answerInteractivePrompt(1)
+        expect(TestUtil.readLine(proc.stdout, ec, timeout) == "Run2 launched")
 
-          analyzeRunOutput( /* restart */ false)
-        }
-      finally
-        if (proc.isAlive()) {
-          proc.destroy()
-          Thread.sleep(200L)
-          if (proc.isAlive())
-            proc.destroyForcibly()
-        }
+        analyzeRunOutput( /* restart */ false)
+      }
     }
   }
 
@@ -2360,31 +2347,22 @@ abstract class RunTestDefinitions
     val inputPath        = os.rel / "smth.scala"
     TestInputs(inputPath -> s"""object Smth extends App { println("$expectedMessage1") }""")
       .fromRoot { root =>
-        val proc = os.proc(TestUtil.cli, "run", ".", "--watch", extraOptions)
-          .spawn(cwd = root, stderr = os.Pipe)
-        try
-          TestUtil.withThreadPool("simple-watch-scala-source-test", 2) { pool =>
-            val timeout = Duration("90 seconds")
-            val ec      = ExecutionContext.fromExecutorService(pool)
-            val output1 = TestUtil.readLine(proc.stdout, ec, timeout)
-            expect(output1 == expectedMessage1)
-            val expectedMessage2 = "World"
-            while (!TestUtil.readLine(proc.stderr, ec, timeout).contains("re-run"))
-              Thread.sleep(100L)
-            os.write.over(
-              root / inputPath,
-              s"""object Smth extends App { println("$expectedMessage2") }""".stripMargin
-            )
-            val output2 = TestUtil.readLine(proc.stdout, ec, timeout)
-            expect(output2 == expectedMessage2)
-          }
-        finally
-          if (proc.isAlive()) {
-            proc.destroy()
-            Thread.sleep(200L)
-            if (proc.isAlive())
-              proc.destroyForcibly()
-          }
+        TestUtil.withProcessWatching(
+          os.proc(TestUtil.cli, "run", ".", "--watch", extraOptions)
+            .spawn(cwd = root, stderr = os.Pipe)
+        ) { (proc, timeout, ec) =>
+          val output1 = TestUtil.readLine(proc.stdout, ec, timeout)
+          expect(output1 == expectedMessage1)
+          val expectedMessage2 = "World"
+          while (!TestUtil.readLine(proc.stderr, ec, timeout).contains("re-run"))
+            Thread.sleep(100L)
+          os.write.over(
+            root / inputPath,
+            s"""object Smth extends App { println("$expectedMessage2") }""".stripMargin
+          )
+          val output2 = TestUtil.readLine(proc.stdout, ec, timeout)
+          expect(output2 == expectedMessage2)
+        }
       }
   }
 }
diff --git a/modules/integration/src/test/scala/scala/cli/integration/RunTestsDefault.scala b/modules/integration/src/test/scala/scala/cli/integration/RunTestsDefault.scala
@@ -2,8 +2,7 @@ package scala.cli.integration
 
 import com.eed3si9n.expecty.Expecty.expect
 
-import scala.concurrent.ExecutionContext
-import scala.concurrent.duration.Duration
+import scala.concurrent.duration.DurationInt
 import scala.util.{Properties, Try}
 
 class RunTestsDefault extends RunTestDefinitions with TestDefault {
@@ -84,7 +83,7 @@ class RunTestsDefault extends RunTestDefinitions with TestDefault {
            |  def hello(name: String) = s"$hello $$name"
            |}
            |""".stripMargin
-      val inputs = TestInputs(
+      TestInputs(
         libSourcePath -> libSource("Hello"),
         os.rel / "app" / "TestApp.scala" ->
           """//> using lib "test-org::messages:0.1.0"
@@ -97,8 +96,7 @@ class RunTestsDefault extends RunTestDefinitions with TestDefault {
             |def run(): Unit =
             |  println(Messages.hello("user"))
             |""".stripMargin
-      )
-      inputs.fromRoot { root =>
+      ).fromRoot { root =>
         val testRepo = root / "test-repo"
 
         def publishLib(): Unit =
@@ -115,90 +113,65 @@ class RunTestsDefault extends RunTestDefinitions with TestDefault {
 
         publishLib()
 
-        val proc = os.proc(
-          TestUtil.cli,
-          "--power",
-          "run",
-          "--offline",
-          "app",
-          "-w",
-          "-r",
-          testRepo.toNIO.toUri.toASCIIString
-        )
-          .spawn(cwd = root)
-
-        try
-          TestUtil.withThreadPool("watch-artifacts-test", 2) { pool =>
-            val timeout = Duration("90 seconds")
-            val ec      = ExecutionContext.fromExecutorService(pool)
-
-            val output = TestUtil.readLine(proc.stdout, ec, timeout)
-            expect(output == "Hello user")
-
-            os.write.over(root / libSourcePath, libSource("Hola"))
-            publishLib()
-
-            val secondOutput = TestUtil.readLine(proc.stdout, ec, timeout)
-            expect(secondOutput == "Hola user")
-          }
-        finally
-          if (proc.isAlive()) {
-            proc.destroy()
-            Thread.sleep(200L)
-            if (proc.isAlive())
-              proc.destroyForcibly()
-          }
+        TestUtil.withProcessWatching(
+          os.proc(
+            TestUtil.cli,
+            "--power",
+            "run",
+            "--offline",
+            "app",
+            "-w",
+            "-r",
+            testRepo.toNIO.toUri.toASCIIString
+          ).spawn(cwd = root)
+        ) { (proc, timeout, ec) =>
+          val output = TestUtil.readLine(proc.stdout, ec, timeout)
+          expect(output == "Hello user")
+
+          os.write.over(root / libSourcePath, libSource("Hola"))
+          publishLib()
+
+          val secondOutput = TestUtil.readLine(proc.stdout, ec, timeout)
+          expect(secondOutput == "Hola user")
+        }
       }
     }
 
   test("watch test - no infinite loop") {
-
     val fileName = "watch.scala"
-
-    val inputs = TestInputs(
+    TestInputs(
       os.rel / fileName ->
         """//> using lib "org.scalameta::munit::0.7.29"
           |
           |class MyTests extends munit.FunSuite {
           |    test("is true true") { assert(true) }
           |}
           |""".stripMargin
-    )
-    inputs.fromRoot { root =>
-      val proc = os.proc(TestUtil.cli, "test", "-w", "watch.scala")
-        .spawn(cwd = root, mergeErrIntoOut = true)
-
-      val watchingMsg = "Watching sources, press Ctrl+C to exit, or press Enter to re-run."
-      val testingMsg  = "MyTests:"
-
-      try
-        TestUtil.withThreadPool("watch-test-test", 2) { pool =>
-          val timeout     = Duration("10 seconds")
-          implicit val ec = ExecutionContext.fromExecutorService(pool)
-
-          def lineReadIter = Iterator.continually(Try(TestUtil.readLine(proc.stdout, ec, timeout)))
-            .takeWhile(_.isSuccess)
-            .map(_.get)
-
-          val beforeAppendOut = lineReadIter.toSeq
-          expect(beforeAppendOut.count(_.contains(testingMsg)) == 1)
-          expect(beforeAppendOut.count(_.contains(watchingMsg)) == 1)
-          expect(beforeAppendOut.last.contains(watchingMsg))
-
-          os.write.append(root / fileName, "\n//comment")
-
-          val afterAppendOut = lineReadIter.toSeq
-          expect(afterAppendOut.count(_.contains(testingMsg)) == 1)
-          expect(afterAppendOut.count(_.contains(watchingMsg)) == 1)
-          expect(afterAppendOut.last.contains(watchingMsg))
-        }
-      finally
-        if (proc.isAlive()) {
-          proc.destroy()
-          Thread.sleep(200L)
-          if (proc.isAlive())
-            proc.destroyForcibly()
-        }
+    ).fromRoot { root =>
+      TestUtil.withProcessWatching(
+        proc = os.proc(TestUtil.cli, "test", "-w", "watch.scala")
+          .spawn(cwd = root, mergeErrIntoOut = true),
+        timeout = 10.seconds
+      ) { (proc, timeout, ec) =>
+        val watchingMsg = "Watching sources, press Ctrl+C to exit, or press Enter to re-run."
+        val testingMsg  = "MyTests:"
+
+        def lineReadIter = Iterator.continually(Try(TestUtil.readLine(proc.stdout, ec, timeout)))
+          .takeWhile(_.isSuccess)
+          .map(_.get)
+
+        val beforeAppendOut = lineReadIter.toSeq
+        expect(beforeAppendOut.count(_.contains(testingMsg)) == 1)
+        expect(beforeAppendOut.count(_.contains(watchingMsg)) == 1)
+        expect(beforeAppendOut.last.contains(watchingMsg))
+
+        os.write.append(root / fileName, "\n//comment")
+
+        val afterAppendOut = lineReadIter.toSeq
+        expect(afterAppendOut.count(_.contains(testingMsg)) == 1)
+        expect(afterAppendOut.count(_.contains(watchingMsg)) == 1)
+        expect(afterAppendOut.last.contains(watchingMsg))
+      }
     }
   }
 
diff --git a/modules/integration/src/test/scala/scala/cli/integration/TestUtil.scala b/modules/integration/src/test/scala/scala/cli/integration/TestUtil.scala
