use ComparableMatcherResult so that IntelliJ shows link for the diff …

…window
fork-handles · Oct 7, 2023 · 94140b0 · 94140b0
1 parent c5bd3eb
commit 94140b0
Show file tree

Hide file tree

Showing 2 changed files with 29 additions and 14 deletions.
diff --git a/result4k/kotest/src/main/kotlin/dev/forkhandles/result4k/kotest/matchers.kt b/result4k/kotest/src/main/kotlin/dev/forkhandles/result4k/kotest/matchers.kt
@@ -3,6 +3,7 @@ package dev.forkhandles.result4k.kotest
 import dev.forkhandles.result4k.Failure
 import dev.forkhandles.result4k.Result
 import dev.forkhandles.result4k.Success
+import io.kotest.matchers.ComparableMatcherResult
 import io.kotest.matchers.Matcher
 import io.kotest.matchers.MatcherResult
 import io.kotest.matchers.should
@@ -59,15 +60,29 @@ infix fun <E> Result<*, E>.shouldBeFailure(expected: E) =
     this should beFailure(expected)
 
 private fun <T, E> Result<T, E>.matchesValue(value: Result<T, E>): MatcherResult =
-    MatcherResult(
+    matcherResultWithIntelliJDiff(
         passed = value == this,
-        failureMessageFn = { "$value should be $this" },
-        negatedFailureMessageFn = { "$value should not be $this" },
+        actual = toString(),
+        expected = value.toString()
     )
 
 private fun <T, E, C : Result<T, E>> Result<T, E>.matchesType(resultClass: KClass<C>): MatcherResult =
-    MatcherResult(
+    matcherResultWithIntelliJDiff(
         passed = resultClass.isInstance(this),
-        failureMessageFn = { "$this should be ${resultClass.simpleName}" },
-        negatedFailureMessageFn = { "$this should not be ${resultClass.simpleName}" },
+        actual = this.toString(),
+        expected = resultClass.simpleName!!
+    )
+
+/**
+ * Return ComparableMatcherResult so that Kotest throws AssertFailedError
+ * with the failure message formatted by io.kotest.assertions.intellijFormatError()
+ * which makes IntelliJ show the link to the diff window.
+ */
+private fun matcherResultWithIntelliJDiff(passed: Boolean, actual: String, expected: String) =
+    ComparableMatcherResult(
+        passed = passed,
+        failureMessageFn = { "" },
+        negatedFailureMessageFn = { "not " },
+        actual = actual,
+        expected = expected
     )
diff --git a/result4k/kotest/src/test/kotlin/dev/forkhandles/result4k/kotest/MatchersTest.kt b/result4k/kotest/src/test/kotlin/dev/forkhandles/result4k/kotest/MatchersTest.kt
@@ -39,13 +39,13 @@ class MatchersTest {
         val value = "Test successful"
         val success = Success(value)
 
-        throwsAssertionError("Success(value=Test successful) should be Failure") {
+        throwsAssertionError("expected:<Failure> but was:<Success(value=Test successful)>") {
             success.shouldBeFailure()
         }
-        throwsAssertionError("Success(value=Test successful) should be Failure") {
+        throwsAssertionError("expected:<Failure> but was:<Success(value=Test successful)>") {
             success.shouldBeFailure { }
         }
-        throwsAssertionError("Success(value=Test successful) should be Failure(reason=Test successful)") {
+        throwsAssertionError("expected:<Success(value=Test successful)> but was:<Failure(reason=Test successful)>") {
             success.shouldBeFailure(value)
         }
     }
@@ -55,23 +55,23 @@ class MatchersTest {
         val reason = "Test failed"
         val failure = Failure(reason)
 
-        throwsAssertionError("Failure(reason=Test failed) should be Success") {
+        throwsAssertionError("expected:<Success> but was:<Failure(reason=Test failed)>") {
             failure.shouldBeSuccess()
         }
-        throwsAssertionError("Failure(reason=Test failed) should be Success") {
+        throwsAssertionError("expected:<Success> but was:<Failure(reason=Test failed)>") {
             failure.shouldBeSuccess { }
         }
-        throwsAssertionError("Failure(reason=Test failed) should be Success(value=Test failed)") {
+        throwsAssertionError("expected:<Failure(reason=Test failed)> but was:<Success(value=Test failed)>") {
             failure.shouldBeSuccess(reason)
         }
     }
 
     @Test
     fun `should correctly assert value`() {
-        throwsAssertionError("Failure(reason=Actual value) should be Failure(reason=Expected value)") {
+        throwsAssertionError("expected:<Failure(reason=Actual value)> but was:<Failure(reason=Expected value)>") {
             Failure("Actual value").shouldBeFailure("Expected value")
         }
-        throwsAssertionError("Success(value=Actual value) should be Success(value=Expected value)") {
+        throwsAssertionError("expected:<Success(value=Actual value)> but was:<Success(value=Expected value)>") {
             Success("Actual value").shouldBeSuccess("Expected value")
         }
     }