Migrate Ammonite REPL tests to Scala 3 REPL

Author: Gedochao

modules/integration/src/test/scala/scala/cli/integration/ReplAmmoniteTestDefinitions.scala

@@ -5,7 +5,7 @@ import com.eed3si9n.expecty.Expecty.expect
 import scala.cli.integration.TestUtil.{normalizeArgsForWindows, removeAnsiColors}
 
 trait ReplAmmoniteTestDefinitions { this: ReplTestDefinitions =>
-  protected val ammonitePrefix: String        = "Ammonite REPL:"
+  protected val ammonitePrefix: String        = "Running in Ammonite REPL:"
   def expectedScalaVersionForAmmonite: String =
     actualScalaVersion match {
       case s

modules/integration/src/test/scala/scala/cli/integration/ReplTestDefinitions.scala

@@ -15,23 +15,39 @@ abstract class ReplTestDefinitions extends ScalaCliSuite with TestScalaVersionAr
     actualScalaVersion.coursierVersion >= "3.7.0-RC1".coursierVersion
 
   protected val dryRunPrefix: String    = "Dry run:"
-  protected val runInReplPrefix: String = "Running in REPL:"
+  protected val runInReplPrefix: String = "Running in Scala REPL:"
 
   def runInRepl(
     codeToRunInRepl: String,
-    testInputs: TestInputs = TestInputs.empty
-  )(f: os.CommandResult => Unit): Unit = {
+    testInputs: TestInputs = TestInputs.empty,
+    cliOptions: Seq[String] = Seq.empty,
+    shouldPipeStdErr: Boolean = false,
+    check: Boolean = true,
+    env: Map[String, String] = Map.empty
+  )(
+    runAfterRepl: os.CommandResult => Unit,
+    runBeforeReplAndGetExtraCliOpts: () => Seq[os.Shellable] = () => Seq.empty
+  ): Unit = {
     testInputs.fromRoot { root =>
-      f(
+      val potentiallyExtraCliOpts = runBeforeReplAndGetExtraCliOpts()
+      runAfterRepl(
         os.proc(
           TestUtil.cli,
           "repl",
+          ".",
           "--repl-quit-after-init",
           "--repl-init-script",
           codeToRunInRepl,
-          extraOptions
+          extraOptions,
+          cliOptions,
+          potentiallyExtraCliOpts
         )
-          .call(cwd = root)
+          .call(
+            cwd = root,
+            stderr = if shouldPipeStdErr then os.Pipe else os.Inherit,
+            env = env,
+            check = check
+          )
       )
     }
   }
@@ -114,11 +130,154 @@ abstract class ReplTestDefinitions extends ScalaCliSuite with TestScalaVersionAr
     expect(output.contains("typer"))
   }
 
-  if canRunInRepl then
+  if canRunInRepl then {
     test(s"$runInReplPrefix simple") {
       val expectedMessage = "1337"
       runInRepl(s"""println($expectedMessage)""")(r =>
         expect(r.out.trim() == expectedMessage)
       )
     }
+
+    test(s"$runInReplPrefix verify Scala version from the REPL") {
+      val opts = if actualScalaVersion.startsWith("3") && !isScala38OrNewer then
+        Seq("--with-compiler")
+      else Seq.empty
+      runInRepl(
+        codeToRunInRepl = s"""println($retrieveScalaVersionCode)""",
+        cliOptions = opts
+      )(r => expect(r.out.trim() == actualScalaVersion))
+    }
+
+    test(s"$runInReplPrefix test scope") {
+      val message = "something something something REPL"
+      runInRepl(
+        codeToRunInRepl = "println(example.TestScopeExample.message)",
+        testInputs = TestInputs(
+          os.rel / "example" / "TestScopeExample.test.scala" ->
+            s"""package example
+               |
+               |object TestScopeExample {
+               |  def message: String = "$message"
+               |}
+               |""".stripMargin
+        ),
+        cliOptions = Seq("--test")
+      )(r => expect(r.out.trim() == message))
+    }
+
+    test(s"$runInReplPrefix ScalaPy") {
+      val opts =
+        if actualScalaVersion.startsWith("3") && !isScala38OrNewer then Seq("--with-compiler")
+        else Seq.empty
+      runInRepl(
+        codeToRunInRepl =
+          s"""import me.shadaj.scalapy.py
+             |println("Hello" + " from Scala " + $retrieveScalaVersionCode)
+             |val sth = py.module("foo.something")
+             |py.Dynamic.global.applyDynamicNamed("print")("" -> sth.messageStart, "" -> sth.messageEnd, "flush" -> py.Any.from(true))
+             |""".stripMargin,
+        testInputs = TestInputs(
+          os.rel / "foo" / "something.py" ->
+            """messageStart = 'Hello from'
+              |messageEnd = 'ScalaPy'
+              |""".stripMargin
+        ),
+        cliOptions = Seq("--python", "--power") ++ opts,
+        shouldPipeStdErr = true
+      ) { res =>
+        val output = res.out.trim().linesIterator.toVector.take(2).mkString("\n")
+        expect(output == s"""Hello from Scala $actualScalaVersion
+                            |Hello from ScalaPy""".stripMargin)
+      }
+    }
+
+    test(s"$runInReplPrefix ScalaPy with PYTHONSAFEPATH") {
+      val opts =
+        if actualScalaVersion.startsWith("3") && !isScala38OrNewer then Seq("--with-compiler")
+        else Seq.empty
+      runInRepl(
+        codeToRunInRepl =
+          s"""import me.shadaj.scalapy.py
+             |println("Hello" + " from Scala " + $retrieveScalaVersionCode)
+             |val sth = py.module("foo.something")
+             |py.Dynamic.global.applyDynamicNamed("print")("" -> sth.messageStart, "" -> sth.messageEnd, "flush" -> py.Any.from(true))
+             |""".stripMargin,
+        testInputs = TestInputs(
+          os.rel / "foo" / "something.py" ->
+            """messageStart = 'Hello from'
+              |messageEnd = 'ScalaPy'
+              |""".stripMargin
+        ),
+        cliOptions = Seq("--python", "--power") ++ opts,
+        shouldPipeStdErr = true,
+        // check = false, // technically should be an error, but the REPL itself doesn't return it as such.
+        env = Map("PYTHONSAFEPATH" -> "foo")
+      ) { errorRes =>
+        // expect(errorRes.exitCode != 0) // technically should be an error, but the REPL itself doesn't return it as such.
+        val errorOutput = TestUtil.removeAnsiColors(errorRes.err.trim() + errorRes.out.trim())
+        expect(errorOutput.contains("No module named 'foo'"))
+      }
+    }
+
+    test(s"$runInReplPrefix with extra JAR") {
+      runInRepl(codeToRunInRepl =
+        """import shapeless._; println("Here's an HList: " + (2 :: true :: "a" :: HNil))"""
+      )(
+        runBeforeReplAndGetExtraCliOpts = () =>
+          val shapelessJar =
+            os.proc(TestUtil.cs, "fetch", "--intransitive", "com.chuusai:shapeless_2.13:2.3.7")
+              .call()
+              .out
+              .text()
+              .trim
+          Seq("--jar", shapelessJar)
+        ,
+        runAfterRepl = res => expect(res.out.trim() == "Here's an HList: 2 :: true :: a :: HNil")
+      )
+    }
+
+    test(s"$runInReplPrefix https://github.com/scala/scala3/issues/21229") {
+      runInRepl(
+        codeToRunInRepl = "println(stuff.baz)",
+        testInputs = TestInputs(
+          os.rel / "Pprint.scala" ->
+            """//> using dep com.lihaoyi::pprint::0.9.0
+              |package stuff
+              |import scala.quoted.*
+              |def foo = pprint(1)
+              |inline def bar = pprint(1)
+              |inline def baz = ${ bazImpl }
+              |def bazImpl(using Quotes) = '{ pprint(1) }
+              |""".stripMargin
+        )
+      )(res => expect(res.out.trim().nonEmpty))
+    }
+
+    test(s"$runInReplPrefix as jar") {
+      val inputs = TestInputs(
+        os.rel / "CheckCp.scala" ->
+          """//> using dep com.lihaoyi::os-lib:0.9.1
+            |package checkcp
+            |class CheckCp
+            |object CheckCp {
+            |  def hasDir: Boolean = {
+            |    val uri: java.net.URI = classOf[checkcp.CheckCp].getProtectionDomain.getCodeSource.getLocation.toURI
+            |    os.isDir(os.Path(java.nio.file.Paths.get(uri)))
+            |  }
+            |}
+            |""".stripMargin
+      )
+      val code = """println("hasDir=" + checkcp.CheckCp.hasDir)"""
+      runInRepl(codeToRunInRepl = code, testInputs = inputs) {
+        res => expect(res.out.trim().contains("hasDir=true"))
+      }
+      runInRepl(
+        codeToRunInRepl = code,
+        testInputs = inputs,
+        cliOptions = Seq("--as-jar", "--power")
+      ) {
+        res => expect(res.out.trim().contains("hasDir=false"))
+      }
+    }
+  }
 }