add integration tests

Author: HollandDM

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

@@ -0,0 +1,21 @@
+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 = gCombinator.combine2(a, b, c)
+
+  def defaultValue: MyNumber = gDefaultValue.defaultValue
+
+}

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

@@ -0,0 +1,21 @@
+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 = gCombinator.combine2(a, b, 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,6 @@
+package lib
+
+trait Combinator[T] {
+  def combine(a: T, b: T): T
+  def combine2(a: T, b: T, c: T): T = combine(combine(a, b), c)
+}

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,122 @@
+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 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.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 syntactically, should not 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")
+      assert(thirdRun.out.isEmpty)
+
+      // Fourth run, Combinator.scala changed sematically, should run MyNumberCombinatorTests & MyStringCombinatorTests
+      modifyFile(
+        workspacePath / "lib" / "src" / "Combinator.scala",
+        _.replace("def combine2(a: T, b: T, c: T): T = combine(combine(a, b), c)", "def combine2(a: T, b: T, c: T): T = combine(a, combine(b, c))")
+      )
+      val fourthRun = eval("app.test.testQuick")
+      val fourthRunOutLines = fourthRun.out.linesIterator.toSeq
+      Seq(
+        "app.MyNumberCombinatorTests.simple",
+        "app.MyStringCombinatorTests.simple"
+      ).foreach { expectedLines =>
+        val exists = fourthRunOutLines.exists(_.contains(expectedLines))
+        assert(exists)
+      }
+
+      // Fifth run, nothing should run because we're not changing anything
+      val fifthRun = eval("app.test.testQuick")
+      assert(fifthRun.out.isEmpty)
+    }
+  }
+}