add integration test

Author: HollandDM

core/define/src/mill/define/Task.scala

@@ -146,7 +146,7 @@ object Task extends TaskBase {
   class CommandFactory private[mill] (val exclusive: Boolean) {
     inline def apply[T](inline t: Result[T])(implicit
         inline w: W[T],
-        inline ctx: mill.define.Ctx
+        inline ctx: mill.define.ModuleCtx
     ): Command[T] = ${ TaskMacros.commandImpl[T]('t)('w, 'ctx, '{ this.exclusive }) }
   }
 
@@ -546,7 +546,7 @@ private object TaskMacros {
       Quotes
   )(t: Expr[Result[T]])(
       w: Expr[W[T]],
-      ctx: Expr[mill.define.Ctx],
+      ctx: Expr[mill.define.ModuleCtx],
       exclusive: Expr[Boolean]
   ): Expr[Command[T]] = {
     appImpl[Command, T](

integration/feature/test-quick/resources/app/src/MyNumber.scala

@@ -0,0 +1,24 @@
+package app
+
+import lib.*
+
+final case class MyNumber(val value: Int)
+
+object MyNumber {
+  
+  given gCombinator: Combinator[MyNumber] = new Combinator[MyNumber] {
+    def combine(a: MyNumber, b: MyNumber): MyNumber = MyNumber(a.value + b.value)
+  }
+
+  given gDefaultValue: DefaultValue[MyNumber] = new DefaultValue[MyNumber] {
+    def defaultValue: MyNumber = MyNumber(0)
+  }
+
+  def combine(a: MyNumber, b: MyNumber, c: MyNumber): MyNumber = {
+    val temp = gCombinator.combine(a, b)
+    gCombinator.combine(temp, c)
+  }
+
+  def defaultValue: MyNumber = gDefaultValue.defaultValue
+
+}

integration/feature/test-quick/resources/app/src/MyString.scala

@@ -0,0 +1,24 @@
+package app
+
+import lib.*
+
+final case class MyString(val value: String)
+
+object MyString {
+  
+  given gCombinator: Combinator[MyString] = new Combinator[MyString] {
+    def combine(a: MyString, b: MyString): MyString = MyString(a.value + b.value)
+  }
+
+  given gDefaultValue: DefaultValue[MyString] = new DefaultValue[MyString] {
+    def defaultValue: MyString = MyString("")
+  }
+
+  def combine(a: MyString, b: MyString, c: MyString): MyString = {
+    val temp = gCombinator.combine(a, b)
+    gCombinator.combine(temp, c)
+  }
+
+  def defaultValue: MyString = gDefaultValue.defaultValue
+
+}

integration/feature/test-quick/resources/app/test/src/MyNumberCombinatorTests.scala

@@ -0,0 +1,16 @@
+package app
+
+import utest.*
+import app.MyNumber
+
+object MyNumberCombinatorTests extends TestSuite {
+  def tests = Tests {
+    test("simple") {
+      val a = MyNumber(1)
+      val b = MyNumber(2)
+      val c = MyNumber(3)
+      val result = MyNumber.combine(a, b, c)
+      assert(result == MyNumber(6))
+    }
+  }
+}

integration/feature/test-quick/resources/app/test/src/MyNumberDefaultValueTests.scala

@@ -0,0 +1,13 @@
+package app
+
+import utest.*
+import app.MyNumber
+
+object MyNumberDefaultValueTests extends TestSuite {
+  def tests = Tests { 
+    test("simple") {
+      val result = MyNumber.defaultValue
+      assert(result == MyNumber(0))
+    }
+  }
+}

integration/feature/test-quick/resources/app/test/src/MyStringCombinatorTests.scala

@@ -0,0 +1,16 @@
+package app
+
+import utest.*
+import app.MyString
+
+object MyStringCombinatorTests extends TestSuite {
+  def tests = Tests {
+    test("simple") {
+      val a = MyString("a")
+      val b = MyString("b")
+      val c = MyString("c")
+      val result = MyString.combine(a, b, c)
+      assert(result == MyString("abc"))
+    }
+  }
+}

integration/feature/test-quick/resources/app/test/src/MyStringDefaultValueTests.scala

@@ -0,0 +1,13 @@
+package app
+
+import utest.*
+import app.MyString
+
+object MyStringDefaultValueTests extends TestSuite {
+  def tests = Tests {
+    test("simple") {
+      val result = MyString.defaultValue
+      assert(result == MyString(""))
+    }
+  }
+}

integration/feature/test-quick/resources/build.mill

@@ -0,0 +1,18 @@
+package build
+
+import mill._, scalalib._
+
+object lib extends ScalaModule {
+  def scalaVersion = "3.3.1"
+}
+
+object app extends ScalaModule {
+  def scalaVersion = "3.3.1"
+  def moduleDeps = Seq(lib)
+
+  object test extends ScalaTests {
+    def ivyDeps = Seq(ivy"com.lihaoyi::utest:0.8.5")
+    def testFramework = "utest.runner.Framework"
+    def moduleDeps = Seq(app)
+  }
+}

integration/feature/test-quick/resources/lib/src/Combinator.scala

@@ -0,0 +1,5 @@
+package lib
+
+trait Combinator[T] {
+  def combine(a: T, b: T): T
+}

integration/feature/test-quick/resources/lib/src/DefaultValue.scala

@@ -0,0 +1,5 @@
+package lib
+
+trait DefaultValue[T] {
+  def defaultValue: T
+}

integration/feature/test-quick/src/TestQuickTests.scala

@@ -0,0 +1,104 @@
+package mill.integration
+
+import mill.testkit.UtestIntegrationTestSuite
+
+import utest._
+
+object TestQuickTests extends UtestIntegrationTestSuite {
+  val tests: Tests = Tests {
+    test("update app file") - integrationTest { tester =>
+      import tester._
+
+      // First run, all tests should run
+      val firstRun = eval("app.test.testQuick")
+      val firstRunOutLines = firstRun.out.linesIterator.toSeq
+      Seq(
+        "app.MyNumberCombinatorTests.simple",
+        "app.MyStringCombinatorTests.simple",
+        "app.MyStringDefaultValueTests.simple",
+        "app.MyNumberDefaultValueTests.simple",
+      ).foreach { expectedLines =>
+        val exists = firstRunOutLines.exists(_.contains(expectedLines))
+        assert(exists)
+      }
+
+      // Second run, nothing should run because we're not changing anything
+      val secondRun = eval("app.test.testQuick")
+      assert(secondRun.out.isEmpty)
+
+      // Third run, MyNumber.scala changed, so MyNumberDefaultValueTests & MyNumberCombinatorTests should run
+      modifyFile(workspacePath / "app" / "src" / "MyNumber.scala", _.replace("def defaultValue: MyNumber = MyNumber(0)", "def defaultValue: MyNumber = MyNumber(1)"))
+      val thirdRun = eval("app.test.testQuick")
+      val thirdRunOutLines = thirdRun.out.linesIterator.toSeq
+      Seq(
+        "app.MyNumberCombinatorTests.simple",
+        "app.MyNumberDefaultValueTests.simple",
+      ).foreach { expectedLines =>
+        val exists = thirdRunOutLines.exists(_.contains(expectedLines))
+        assert(exists)
+      }
+
+      // Fourth run, MyNumberDefaultValueTests was failed, so it should run again
+      val fourthRun = eval("app.test.testQuick")
+      val fourthRunOutLines = fourthRun.out.linesIterator.toSeq
+      Seq(
+        "app.MyNumberDefaultValueTests.simple",
+      ).foreach { expectedLines =>
+        val exists = fourthRunOutLines.exists(_.contains(expectedLines))
+        assert(exists)
+      }
+
+      // Fifth run, MyNumberDefaultValueTests was fixed, so it should run again
+      modifyFile(workspacePath / "app" / "test" / "src" / "MyNumberDefaultValueTests.scala", _.replace("assert(result == MyNumber(0))", "assert(result == MyNumber(1))"))
+      val fifthRun = eval("app.test.testQuick")
+      val fifthRunOutLines = fifthRun.out.linesIterator.toSeq
+      Seq(
+        "app.MyNumberDefaultValueTests.simple",
+      ).foreach { expectedLines =>
+        val exists = fifthRunOutLines.exists(_.contains(expectedLines))
+        assert(exists)
+      }
+
+      // Sixth run, nothing should run because we're not changing anything
+      val sixthRun = eval("app.test.testQuick")
+      assert(sixthRun.out.isEmpty)
+    }
+    test("update lib file") - integrationTest { tester =>
+      import tester._
+
+      // First run, all tests should run
+      val firstRun = eval("app.test.testQuick")
+      val firstRunOutLines = firstRun.out.linesIterator.toSeq
+      Seq(
+        "app.MyNumberCombinatorTests.simple",
+        "app.MyStringCombinatorTests.simple",
+        "app.MyStringDefaultValueTests.simple",
+        "app.MyNumberDefaultValueTests.simple",
+      ).foreach { expectedLines =>
+        val exists = firstRunOutLines.exists(_.contains(expectedLines))
+        assert(exists)
+      }
+
+      // Second run, nothing should run because we're not changing anything
+      val secondRun = eval("app.test.testQuick")
+      assert(secondRun.out.isEmpty)
+
+      // Third run, Combinator.scala changed, so MyNumberCombinatorTests & MyStringCombinatorTests should run
+      modifyFile(workspacePath / "lib" / "src" / "Combinator.scala", _.replace("def combine(a: T, b: T): T", "def combine(b: T, a: T): T"))
+      val thirdRun = eval("app.test.testQuick")
+      val thirdRunOutLines = thirdRun.out.linesIterator.toSeq
+      Seq(
+        "app.MyNumberCombinatorTests.simple",
+        "app.MyStringCombinatorTests.simple",
+      ).foreach { expectedLines =>
+        val exists = thirdRunOutLines.exists(_.contains(expectedLines))
+        assert(exists)
+      }
+
+      // Fourth run, nothing should run because we're not changing anything
+      val fourthRun = eval("app.test.testQuick")
+      assert(fourthRun.out.isEmpty)
+    }
+  }
+}
+

scalalib/src/mill/scalalib/JavaModule.scala

@@ -233,20 +233,21 @@ trait JavaModule
         testUseArgsFile(),
         forkArgs(),
         Seq.empty,
-        zincWorker().scalalibClasspath(),
+        jvmWorker().scalalibClasspath(),
         resources(),
         testFramework(),
         runClasspath(),
         testClasspaths,
         args.toSeq,
         testClasses,
-        zincWorker().testrunnerEntrypointClasspath(),
+        jvmWorker().testrunnerEntrypointClasspath(),
         forkEnv(),
         testSandboxWorkingDir(),
         forkWorkingDir(),
         quickTestReportXml,
-        zincWorker().javaHome().map(_.path),
-        testParallelism()
+        jvmWorker().javaHome().map(_.path),
+        testParallelism(),
+        testLogLevel()
       )
 
       val results = testModuleUtil.runTests()