improvements to golden testing

Author: lihaoyi

utest/src-jvm/utest/asserts/AssertsPlatformSpecific.scala

@@ -4,49 +4,48 @@ import utest.framework.{GoldenFix}
 import utest.{AssertionError, TestValue}
 import java.nio.file.{Files, Path}
 trait AssertsPlatformSpecific {
-  def assertGoldenFile(testValue: String, path: Path)(implicit reporter: GoldenFix.Reporter): Unit = {
-    val goldenFileContents = if (Files.exists(path)) Files.readString(path) else ""
-    if (goldenFileContents != testValue) {
-      if (!sys.env.contains("UTEST_UPDATE_GOLDEN_TESTS")) {
-        throw new AssertionError(
-          "Value does not match golden file contents\n" +
-          "Run UTEST_UPDATE_GOLDEN_TESTS=1 to update golden file " + path,
-          Seq(
-            TestValue.Equality(
-              TestValue.Single("goldenFileContents", None, goldenFileContents),
-              TestValue.Single("testValue", None, testValue),
-            )
-          )
+  private def throwAssertionError(path: String, goldenValue: Any, actualValue: Any): Unit = {
+    throw new AssertionError(
+      s"Actual value does not match golden data in file $path\n" +
+        "Run tests with UTEST_UPDATE_GOLDEN_TESTS=1 to apply the following patch to update the golden value",
+      Seq(
+        TestValue.Equality(
+          TestValue.Single("goldenValue", None, goldenValue),
+          TestValue.Single("actualValue", None, actualValue),
         )
-      }
-      else {
-        reporter.apply(GoldenFix(path, testValue, 0, goldenFileContents.length))
+      )
+    )
+
+  }
+  def assertGoldenFile(actualValue: String, goldenFilePath: Path)(implicit reporter: GoldenFix.Reporter): Unit = {
+    val goldenFileContents = if (Files.exists(goldenFilePath)) Files.readString(goldenFilePath) else ""
+    if (goldenFileContents != actualValue) {
+      if (!sys.env.get("UTEST_UPDATE_GOLDEN_TESTS").exists(_.nonEmpty)) {
+        throwAssertionError(goldenFilePath.toString, goldenFileContents, actualValue)
+      } else {
+        reporter.apply(GoldenFix(goldenFilePath, actualValue, 0, goldenFileContents.length))
       }
     }
   }
 
-  def assertGoldenLiteral(testValue: Any, golden: GoldenFix.Span[Any])
+  def assertGoldenLiteral(actualValue: Any, goldenLiteral: GoldenFix.Span[Any])
                          (implicit reporter: GoldenFix.Reporter): Unit = {
-    val goldenValue = golden.value
-    if (testValue != goldenValue) {
-      if (!sys.env.contains("UTEST_UPDATE_GOLDEN_TESTS")) {
-        throw new AssertionError(
-          "Value does not match golden literal contents\n" +
-            "Run UTEST_UPDATE_GOLDEN_TESTS=1 to update golden literal in " + golden.sourceFile,
-          Seq(
-            TestValue.Equality(
-              TestValue.Single("testValue", None, testValue),
-              TestValue.Single("goldenValue", None, goldenValue),
-            )
-          )
-        )
+    Predef.assert(
+      goldenLiteral != null,
+      "assertGoldenLiteral does not allow `null` as the golden literal," +
+        "please use `()` if you want a placeholder for `UTEST_UPDATE_GOLDEN_TESTS=1` to fill in"
+    )
+    val goldenValue = goldenLiteral.value
+    if (actualValue != goldenValue) {
+      if (!sys.env.get("UTEST_UPDATE_GOLDEN_TESTS").exists(_.nonEmpty)) {
+        throwAssertionError(goldenLiteral.sourceFile, goldenValue, actualValue)
       } else {
         reporter.apply(
           GoldenFix(
-            Path.of(golden.sourceFile),
-            utest.shaded.pprint.PPrinter.BlackWhite.apply(golden.value).plainText,
-            golden.startOffset,
-            golden.endOffset
+            Path.of(goldenLiteral.sourceFile),
+            utest.shaded.pprint.PPrinter.BlackWhite.apply(actualValue).plainText,
+            goldenLiteral.startOffset,
+            goldenLiteral.endOffset
           )
         )
       }

utest/src-jvm/utest/framework/GoldenFix.scala

@@ -41,12 +41,12 @@ object GoldenFix {
     lineStarts.toArray
   }
 
-  def columnLookup(index: Int, lineNumberLookup: Array[Int]): Int = {
+  def lineColumnLookup(index: Int, lineNumberLookup: Array[Int]): (Int, Int) = {
     val line = lineNumberLookup.indexWhere(_ > index) match {
       case -1 => lineNumberLookup.length - 1
       case n => math.max(0, n - 1)
     }
-    index - lineNumberLookup(line)
+    (line, index - lineNumberLookup(line))
   }
 
   trait Reporter {
@@ -55,10 +55,8 @@ object GoldenFix {
 
   def applyAll(fixes: Seq[GoldenFix]): Unit = {
     for((path, group) <- fixes.groupBy(_.path)){
-      println(s"Applying ${group.size} golden fixes to file $path")
-
+      println(s"UTEST_UPDATE_GOLDEN_TESTS detected, uTest applying ${group.size} golden fixes to file $path")
       val text = java.nio.file.Files.readString(path)
-
       java.nio.file.Files.writeString(path, applyToText(text, group))
     }
   }
@@ -73,8 +71,10 @@ object GoldenFix {
     val lineNumberLookupTable = lineNumberLookup(text)
     var lengthOffset = 0
     for (fix <- sorted) {
-      val col = columnLookup(fix.startOffset, lineNumberLookupTable)
-      val indentedContents = fix.contents.linesWithSeparators.mkString(" " * col)
+      val (startLine, startCol) = lineColumnLookup(fix.startOffset, lineNumberLookupTable)
+      val (endLine, endCol) = lineColumnLookup(fix.endOffset, lineNumberLookupTable)
+      println(s"Updating line:column $startLine:$startCol to $endLine:$endCol")
+      val indentedContents = fix.contents.linesWithSeparators.mkString(" " * startCol)
       text = text.patch(
         fix.startOffset + lengthOffset, indentedContents,
         fix.endOffset - fix.startOffset

utest/src-jvm/utest/framework/TestSuitePlatformSpecific.scala

@@ -9,7 +9,6 @@ trait TestSuitePlatformSpecific {
 
 object TestSuitePlatformSpecific {
   def processGolden(allSuites: Seq[utest.TestSuite]): Unit = {
-    println("TestSuitePlatformSpecific.processGolden: " + allSuites.length)
     if (sys.env.contains("UTEST_UPDATE_GOLDEN_TESTS")) {
       val goldenFixes = allSuites.flatMap { suite =>
         suite.utestGoldenReports.synchronized {