Added standalone tests for SBT import

Author: ajaychandran

standalone/migrating/sbt/src/MillInitCatsTests.scala

@@ -0,0 +1,26 @@
+package mill.standalone
+
+import utest.*
+
+object MillInitCatsTests extends GitRepoStandaloneTestSuite {
+
+  def gitRepoUrl = "[email protected]:typelevel/cats.git"
+  def gitRepoBranch = "v2.13.0"
+
+  def tests = Tests {
+    test - standaloneTest { tester =>
+      import tester.*
+
+      eval("init").isSuccess ==> true
+      eval("__.compile").isSuccess ==> true
+      eval("__.test").isSuccess ==> true
+      /*
+[6380] 6 tasks failed
+[6380] kernel-laws.native.resolvedMvnDeps java.lang.RuntimeException:
+[6380] Resolution failed for 7 modules:
+[6380] --------------------------------------------
+[6380]   org.scala-native:auxlib_2.13:0.5.6
+       */
+    }
+  }
+}

standalone/migrating/sbt/src/MillInitLilaTests.scala

@@ -0,0 +1,24 @@
+package mill.standalone
+
+import utest.*
+
+object MillInitLilaTests extends GitRepoStandaloneTestSuite {
+
+  def gitRepoUrl = "[email protected]:lichess-org/lila.git"
+  def gitRepoBranch = "master"
+
+  def tests = Tests {
+    test - standaloneTest { tester =>
+      import tester.*
+
+      eval("init").isSuccess ==> true
+      eval("__.compile").isSuccess ==> true
+      /*
+[6380] [error] -- [E8] .../mill/out/standalone/migrating/sbt/packaged/nodaemon/testOnly.dest/sandbox/clone/lila/modules/analyse/package.mill:73:69
+[6380] [error] 73 │    def moduleDeps = super.moduleDeps ++ Seq(build.modules.coreI18n.test)
+[6380] [error]    │                                                                    ^^^^
+[6380] [error]    │value test is not a member of object build_.modules.coreI18n.package_
+       */
+    }
+  }
+}

standalone/migrating/sbt/src/MillInitScala3Tests.scala

@@ -0,0 +1,21 @@
+package mill.standalone
+
+import utest.*
+
+object MillInitScala3Tests extends GitRepoStandaloneTestSuite {
+
+  def gitRepoUrl = "[email protected]:scala/scala3.git"
+  def gitRepoBranch = "3.7.1"
+
+  def tests = Tests {
+    test - standaloneTest { tester =>
+      import tester.*
+
+      eval("init").isSuccess ==> true
+      eval("__.compile").isSuccess ==> true
+      /*
+[6380] Exception in thread "main" java.lang.IllegalArgumentException: Project at duplicate locations
+       */
+    }
+  }
+}

standalone/migrating/sbt/src/MillInitScalaPBTests.scala

@@ -0,0 +1,22 @@
+package mill.standalone
+
+import utest.*
+
+object MillInitScalaPBTests extends GitRepoStandaloneTestSuite {
+
+  def gitRepoUrl = "[email protected]:scalapb/ScalaPB.git"
+  def gitRepoBranch = "v0.11.19"
+
+  def tests = Tests {
+    test - standaloneTest { tester =>
+      import tester.*
+
+      eval("init").isSuccess ==> true
+      eval("__.compile").isSuccess ==> true
+      eval("__.test").isSuccess ==> true
+      /*
+[6380] Cannot resolve __.test. Try `mill resolve _` to see what's available.
+       */
+    }
+  }
+}

standalone/package.mill

@@ -0,0 +1,34 @@
+package build.standalone
+
+import mill.scalalib.TestModule
+import mill.{Cross, Module}
+import millbuild._
+
+object `package` extends Module {
+
+  trait StandaloneTestModule extends Cross.Module[String] with MillBaseTestsModule
+      with TestModule.Utest {
+    def moduleDir = super.moduleDir / crossValue
+    def moduleDeps = Seq(build.core.eval, testkit)
+    def mvnDeps = Seq(Deps.TestDeps.utest)
+
+    def forkArgs = super.forkArgs() ++ build.dist.forkArgs()
+    def forkEnv = super.forkEnv() ++
+      Map(
+        "MILL_STANDALONE_EXECUTABLE" -> build.dist.launcher().path.toString(),
+        "MILL_STANDALONE_DAEMON_MODE" -> "false"
+      ) ++
+      build.dist.localTestOverridesEnv()
+  }
+
+  object migrating extends Cross[StandaloneCrossTestModule](build.listCross)
+  trait StandaloneCrossTestModule extends MillScalaModule with StandaloneTestModule {
+    override def moduleDeps = super[StandaloneTestModule].moduleDeps
+    def scalaVersion = Deps.scalaVersion
+  }
+
+  object testkit extends MillScalaModule {
+    def moduleDeps = Seq(build.core.eval)
+    def mvnDeps = Seq(Deps.TestDeps.utest)
+  }
+}

standalone/testkit/src/mill/standalone/GitRepoStandaloneTestSuite.scala

@@ -0,0 +1,16 @@
+package mill.standalone
+
+trait GitRepoStandaloneTestSuite extends utest.TestSuite, StandaloneTestSuite {
+
+  def gitRepoUrl: String
+  def gitRepoBranch: String
+  def gitRepoDepth: Int = 1
+
+  def workspacePath = {
+    val cwd = os.temp.dir(dir = os.pwd, deleteOnExit = false)
+    // preserve repo dir name for a realistic reproduction
+    os.proc("git", "clone", gitRepoUrl, "--depth", gitRepoDepth, "--branch", gitRepoBranch)
+      .call(cwd = cwd)
+    os.list(cwd).head
+  }
+}

standalone/testkit/src/mill/standalone/StandaloneTestSuite.scala

@@ -0,0 +1,27 @@
+package mill.standalone
+
+trait StandaloneTestSuite {
+
+  protected def millExecutable: os.Path =
+    os.Path(System.getenv("MILL_STANDALONE_EXECUTABLE"), os.pwd)
+
+  protected def daemonMode: Boolean =
+    sys.env("MILL_STANDALONE_DAEMON_MODE").toBoolean
+
+  def debugLog = false
+
+  protected def propagateJavaHome: Boolean = true
+
+  def workspacePath: os.Path
+
+  def standaloneTest[T](block: StandaloneTester => T): T = {
+    val tester = StandaloneTester(
+      millExecutable,
+      daemonMode,
+      debugLog,
+      workspacePath,
+      propagateJavaHome
+    )
+    block(tester)
+  }
+}

standalone/testkit/src/mill/standalone/StandaloneTester.scala

@@ -0,0 +1,104 @@
+package mill.standalone
+
+import mill.constants.DaemonFiles.processId
+import mill.constants.OutFiles.{millDaemon, millNoDaemon, out}
+import os.{Path, ProcessInput, ProcessOutput, Shellable}
+
+class StandaloneTester(
+    val millExecutable: os.Path,
+    val daemonMode: Boolean,
+    val debugLog: Boolean = false,
+    val workspacePath: os.Path = os.pwd,
+    val propagateJavaHome: Boolean = true
+) extends StandaloneTester.Impl
+
+object StandaloneTester {
+
+  case class EvalResult(exitCode: Int, out: String, err: String) {
+    def isSuccess: Boolean = exitCode == 0
+
+    def debugString: String = {
+      s"""Success: $isSuccess (exit code: $exitCode)
+         |
+         |stdout:
+         |$out
+         |
+         |stderr:
+         |$err
+         |""".stripMargin
+    }
+  }
+
+  trait Impl extends AutoCloseable {
+
+    def workspacePath: os.Path
+
+    def millExecutable: os.Path
+
+    def daemonMode: Boolean
+
+    def debugLog: Boolean
+
+    def propagateJavaHome: Boolean
+
+    def millTestSuiteEnv: Map[String, String] = Option.when(propagateJavaHome)(
+      "JAVA_HOME" -> sys.props("java.home")
+    ).toMap
+
+    def eval(
+        cmd: Shellable,
+        env: Map[String, String] = Map(),
+        cwd: Path = workspacePath,
+        stdin: ProcessInput = os.Pipe,
+        stdout: ProcessOutput = os.Pipe,
+        stderr: ProcessOutput = os.Pipe,
+        mergeErrIntoOut: Boolean = false,
+        timeout: Long = -1,
+        check: Boolean = false,
+        shutdownGracePeriod: Long = 100
+    ) = {
+      val serverArgs = Option.when(!daemonMode)("--no-daemon")
+      val debugArgs = Option.when(debugLog)("--debug")
+      val cmd0: os.Shellable = (millExecutable, serverArgs, debugArgs, cmd)
+
+      val callEnv = millTestSuiteEnv ++ env
+
+      val res0 = os.call(
+        cmd0,
+        env = callEnv,
+        cwd = cwd,
+        stdin = stdin,
+        stdout = stdout,
+        stderr = stderr,
+        mergeErrIntoOut = mergeErrIntoOut,
+        timeout = timeout,
+        check = check,
+        shutdownGracePeriod = shutdownGracePeriod
+      )
+
+      EvalResult(
+        res0.exitCode,
+        fansi.Str(res0.out.text(), errorMode = fansi.ErrorMode.Strip).plainText.trim,
+        fansi.Str(res0.err.text(), errorMode = fansi.ErrorMode.Strip).plainText.trim
+      )
+    }
+
+    def close() = removeProcessIdFile()
+
+    def removeProcessIdFile() = {
+      val outDir = os.Path(out, workspacePath)
+      if (os.exists(outDir)) {
+        if (daemonMode) {
+          val serverPath = outDir / millDaemon
+          os.remove(serverPath / processId)
+        } else {
+          val serverPath0 = outDir / millNoDaemon
+
+          for (serverPath <- os.list.stream(serverPath0)) os.remove(serverPath / processId)
+
+        }
+        Thread.sleep(500) // give a moment for the server to notice the file is gone and exit
+      }
+    }
+  }
+}