Use failure with actual and expected message to improve IDE experience (#5550)

filiphr · web-flow · commit 4a29322e5985 · 2024-10-07T17:29:40.000+09:00
diff --git a/micrometer-observation-test/src/main/java/io/micrometer/observation/tck/ObservationContextAssert.java b/micrometer-observation-test/src/main/java/io/micrometer/observation/tck/ObservationContextAssert.java
@@ -71,7 +71,8 @@ public SELF hasNameEqualTo(String name) {
         isNotNull();
         String actualName = this.actual.getName();
         if (!Objects.equals(name, actualName)) {
-            failWithMessage("Observation should have name equal to <%s> but has <%s>", name, actualName);
+            failWithActualExpectedAndMessage(actualName, name,
+                    "Observation should have name equal to <%s> but has <%s>", name, actualName);
         }
         return (SELF) this;
     }
@@ -89,7 +90,8 @@ public SELF hasNameEqualToIgnoringCase(String name) {
         isNotNull();
         String actualName = this.actual.getName();
         if (!name.equalsIgnoreCase(actualName)) {
-            failWithMessage("Observation should have name equal to ignoring case <%s> but has <%s>", name, actualName);
+            failWithActualExpectedAndMessage(actualName, name,
+                    "Observation should have name equal to ignoring case <%s> but has <%s>", name, actualName);
         }
         return (SELF) this;
     }
@@ -107,7 +109,8 @@ public SELF hasContextualNameEqualTo(String name) {
         isNotNull();
         String actualName = this.actual.getContextualName();
         if (!Objects.equals(name, actualName)) {
-            failWithMessage("Observation should have contextual name equal to <%s> but has <%s>", name, actualName);
+            failWithActualExpectedAndMessage(actualName, name,
+                    "Observation should have contextual name equal to <%s> but has <%s>", name, actualName);
         }
         return (SELF) this;
     }
@@ -125,7 +128,8 @@ public SELF hasContextualNameEqualToIgnoringCase(String name) {
         isNotNull();
         String actualName = this.actual.getContextualName();
         if (!name.equalsIgnoreCase(actualName)) {
-            failWithMessage("Observation should have contextual name equal to ignoring case <%s> but has <%s>", name,
+            failWithActualExpectedAndMessage(actualName, name,
+                    "Observation should have contextual name equal to ignoring case <%s> but has <%s>", name,
                     actualName);
         }
         return (SELF) this;
@@ -251,7 +255,7 @@ public SELF hasLowCardinalityKeyValue(String key, String value) {
             .get()
             .getValue();
         if (!Objects.equals(tagValue, value)) {
-            failWithMessage(
+            failWithActualExpectedAndMessage(tagValue, value,
                     "Observation should have a low cardinality tag with key <%s> and value <%s>. The key is correct but the value is <%s>",
                     key, value, tagValue);
         }
@@ -328,7 +332,7 @@ public SELF hasHighCardinalityKeyValue(String key, String value) {
             .get()
             .getValue();
         if (!Objects.equals(tagValue, value)) {
-            failWithMessage(
+            failWithActualExpectedAndMessage(tagValue, value,
                     "Observation should have a high cardinality tag with key <%s> and value <%s>. The key is correct but the value is <%s>",
                     key, value, tagValue);
         }
@@ -462,7 +466,8 @@ public SELF hasParentObservationEqualTo(Observation expectedParent) {
             failWithMessage("Observation should have parent <%s> but has none", expectedParent);
         }
         if (!realParent.equals(expectedParent)) {
-            failWithMessage("Observation should have parent <%s> but has <%s>", expectedParent, realParent);
+            failWithActualExpectedAndMessage(realParent, expectedParent,
+                    "Observation should have parent <%s> but has <%s>", expectedParent, realParent);
         }
         return (SELF) this;
     }
diff --git a/micrometer-observation-test/src/test/java/io/micrometer/observation/tck/ObservationContextAssertTests.java b/micrometer-observation-test/src/test/java/io/micrometer/observation/tck/ObservationContextAssertTests.java
@@ -21,10 +21,12 @@
 import io.micrometer.observation.ObservationRegistry;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.opentest4j.AssertionFailedError;
 
 import java.util.function.Supplier;
 
 import static io.micrometer.observation.tck.ObservationContextAssert.assertThat;
+import static org.assertj.core.api.BDDAssertions.then;
 import static org.assertj.core.api.BDDAssertions.thenNoException;
 import static org.assertj.core.api.BDDAssertions.thenThrownBy;
 import static org.mockito.Mockito.spy;
@@ -63,7 +65,11 @@ void should_not_throw_exception_when_name_correct() {
     void should_throw_exception_when_name_incorrect() {
         context.setName("foo");
 
-        thenThrownBy(() -> assertThat(context).hasNameEqualTo("bar")).isInstanceOf(AssertionError.class);
+        thenThrownBy(() -> assertThat(context).hasNameEqualTo("bar")).isInstanceOfSatisfying(AssertionFailedError.class,
+                error -> {
+                    then(error.getActual().getStringRepresentation()).isEqualTo("foo");
+                    then(error.getExpected().getStringRepresentation()).isEqualTo("bar");
+                });
     }
 
     @Test
@@ -91,7 +97,11 @@ void should_not_throw_exception_when_contextual_name_correct() {
     void should_throw_exception_when_contextual_name_incorrect() {
         context.setContextualName("foo");
 
-        thenThrownBy(() -> assertThat(context).hasContextualNameEqualTo("bar")).isInstanceOf(AssertionError.class);
+        thenThrownBy(() -> assertThat(context).hasContextualNameEqualTo("bar"))
+            .isInstanceOfSatisfying(AssertionFailedError.class, error -> {
+                then(error.getActual().getStringRepresentation()).isEqualTo("foo");
+                then(error.getExpected().getStringRepresentation()).isEqualTo("bar");
+            });
     }
 
     @Test
@@ -120,7 +130,11 @@ void should_not_throw_exception_when_name_ignore_case_correct() {
     void should_throw_exception_when_name_ignore_case_incorrect() {
         context.setName("foo");
 
-        thenThrownBy(() -> assertThat(context).hasNameEqualToIgnoringCase("bar")).isInstanceOf(AssertionError.class);
+        thenThrownBy(() -> assertThat(context).hasNameEqualToIgnoringCase("bar"))
+            .isInstanceOfSatisfying(AssertionFailedError.class, error -> {
+                then(error.getActual().getStringRepresentation()).isEqualTo("foo");
+                then(error.getExpected().getStringRepresentation()).isEqualTo("bar");
+            });
     }
 
     @Test
@@ -150,7 +164,10 @@ void should_throw_exception_when_contextual_name_ignore_case_incorrect() {
         context.setContextualName("foo");
 
         thenThrownBy(() -> assertThat(context).hasContextualNameEqualToIgnoringCase("bar"))
-            .isInstanceOf(AssertionError.class);
+            .isInstanceOfSatisfying(AssertionFailedError.class, error -> {
+                then(error.getActual().getStringRepresentation()).isEqualTo("foo");
+                then(error.getExpected().getStringRepresentation()).isEqualTo("bar");
+            });
     }
 
     @Test
@@ -248,7 +265,10 @@ void should_throw_exception_when_low_cardinality_key_value_missing() {
         observation.lowCardinalityKeyValue("foo", "bar");
 
         thenThrownBy(() -> assertThat(context).hasLowCardinalityKeyValue("foo", "baz"))
-            .isInstanceOf(AssertionError.class);
+            .isInstanceOfSatisfying(AssertionFailedError.class, error -> {
+                then(error.getActual().getStringRepresentation()).isEqualTo("bar");
+                then(error.getExpected().getStringRepresentation()).isEqualTo("baz");
+            });
         thenThrownBy(() -> assertThat(context).hasLowCardinalityKeyValueWithKey("bar"))
             .isInstanceOf(AssertionError.class);
     }
@@ -284,7 +304,10 @@ void should_throw_exception_when_high_cardinality_key_value_missing() {
         observation.highCardinalityKeyValue("foo", "bar");
 
         thenThrownBy(() -> assertThat(context).hasHighCardinalityKeyValue("foo", "baz"))
-            .isInstanceOf(AssertionError.class);
+            .isInstanceOfSatisfying(AssertionFailedError.class, error -> {
+                then(error.getActual().getStringRepresentation()).isEqualTo("bar");
+                then(error.getExpected().getStringRepresentation()).isEqualTo("baz");
+            });
         thenThrownBy(() -> assertThat(context).hasHighCardinalityKeyValueWithKey("bar"))
             .isInstanceOf(AssertionError.class);
     }

Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,8 @@ public SELF hasNameEqualTo(String name) {`
`71`	`71`	`isNotNull();`
`72`	`72`	`String actualName = this.actual.getName();`
`73`	`73`	`if (!Objects.equals(name, actualName)) {`
`74`		`- failWithMessage("Observation should have name equal to <%s> but has <%s>", name, actualName);`
	`74`	`+ failWithActualExpectedAndMessage(actualName, name,`
	`75`	`+ "Observation should have name equal to <%s> but has <%s>", name, actualName);`
`75`	`76`	`}`
`76`	`77`	`return (SELF) this;`
`77`	`78`	`}`
`@@ -89,7 +90,8 @@ public SELF hasNameEqualToIgnoringCase(String name) {`
`89`	`90`	`isNotNull();`
`90`	`91`	`String actualName = this.actual.getName();`
`91`	`92`	`if (!name.equalsIgnoreCase(actualName)) {`
`92`		`- failWithMessage("Observation should have name equal to ignoring case <%s> but has <%s>", name, actualName);`
	`93`	`+ failWithActualExpectedAndMessage(actualName, name,`
	`94`	`+ "Observation should have name equal to ignoring case <%s> but has <%s>", name, actualName);`
`93`	`95`	`}`
`94`	`96`	`return (SELF) this;`
`95`	`97`	`}`
`@@ -107,7 +109,8 @@ public SELF hasContextualNameEqualTo(String name) {`
`107`	`109`	`isNotNull();`
`108`	`110`	`String actualName = this.actual.getContextualName();`
`109`	`111`	`if (!Objects.equals(name, actualName)) {`
`110`		`- failWithMessage("Observation should have contextual name equal to <%s> but has <%s>", name, actualName);`
	`112`	`+ failWithActualExpectedAndMessage(actualName, name,`
	`113`	`+ "Observation should have contextual name equal to <%s> but has <%s>", name, actualName);`
`111`	`114`	`}`
`112`	`115`	`return (SELF) this;`
`113`	`116`	`}`
`@@ -125,7 +128,8 @@ public SELF hasContextualNameEqualToIgnoringCase(String name) {`
`125`	`128`	`isNotNull();`
`126`	`129`	`String actualName = this.actual.getContextualName();`
`127`	`130`	`if (!name.equalsIgnoreCase(actualName)) {`
`128`		`- failWithMessage("Observation should have contextual name equal to ignoring case <%s> but has <%s>", name,`
	`131`	`+ failWithActualExpectedAndMessage(actualName, name,`
	`132`	`+ "Observation should have contextual name equal to ignoring case <%s> but has <%s>", name,`
`129`	`133`	`actualName);`
`130`	`134`	`}`
`131`	`135`	`return (SELF) this;`
`@@ -251,7 +255,7 @@ public SELF hasLowCardinalityKeyValue(String key, String value) {`
`251`	`255`	`.get()`
`252`	`256`	`.getValue();`
`253`	`257`	`if (!Objects.equals(tagValue, value)) {`
`254`		`- failWithMessage(`
	`258`	`+ failWithActualExpectedAndMessage(tagValue, value,`
`255`	`259`	`"Observation should have a low cardinality tag with key <%s> and value <%s>. The key is correct but the value is <%s>",`
`256`	`260`	`key, value, tagValue);`
`257`	`261`	`}`
`@@ -328,7 +332,7 @@ public SELF hasHighCardinalityKeyValue(String key, String value) {`
`328`	`332`	`.get()`
`329`	`333`	`.getValue();`
`330`	`334`	`if (!Objects.equals(tagValue, value)) {`
`331`		`- failWithMessage(`
	`335`	`+ failWithActualExpectedAndMessage(tagValue, value,`
`332`	`336`	`"Observation should have a high cardinality tag with key <%s> and value <%s>. The key is correct but the value is <%s>",`
`333`	`337`	`key, value, tagValue);`
`334`	`338`	`}`
`@@ -462,7 +466,8 @@ public SELF hasParentObservationEqualTo(Observation expectedParent) {`
`462`	`466`	`failWithMessage("Observation should have parent <%s> but has none", expectedParent);`
`463`	`467`	`}`
`464`	`468`	`if (!realParent.equals(expectedParent)) {`
`465`		`- failWithMessage("Observation should have parent <%s> but has <%s>", expectedParent, realParent);`
	`469`	`+ failWithActualExpectedAndMessage(realParent, expectedParent,`
	`470`	`+ "Observation should have parent <%s> but has <%s>", expectedParent, realParent);`
`466`	`471`	`}`
`467`	`472`	`return (SELF) this;`
`468`	`473`	`}`