From f185b08258761391885e08ff4e8f7fa5414180c7 Mon Sep 17 00:00:00 2001 From: Tim te Beek Date: Mon, 14 Apr 2025 20:46:28 +0000 Subject: [PATCH 1/2] refactor: Collapse consecutive `assertThat` statements Use this link to re-run the recipe: https://app.moderne.io/recipes/org.openrewrite.java.testing.assertj.CollapseConsecutiveAssertThatStatements?organizationId=NWEyODY5YjUtYjZkYS00MDY1LTg5M2YtNjI4YTBlZmE5NzQ3 Co-authored-by: Moderne --- .../examples/ArrayAssertionsExamples.java | 22 ++++---- .../examples/BasicAssertionsExamples.java | 19 +++---- .../examples/IterableAssertionsExamples.java | 40 ++++++++------- .../examples/MapAssertionsExamples.java | 50 ++++++++++--------- 4 files changed, 71 insertions(+), 60 deletions(-) diff --git a/assertions-examples/src/test/java/org/assertj/examples/ArrayAssertionsExamples.java b/assertions-examples/src/test/java/org/assertj/examples/ArrayAssertionsExamples.java index 25e61960..29a93696 100644 --- a/assertions-examples/src/test/java/org/assertj/examples/ArrayAssertionsExamples.java +++ b/assertions-examples/src/test/java/org/assertj/examples/ArrayAssertionsExamples.java @@ -65,18 +65,21 @@ public void array_assertions_examples() { Movie[] trilogy = array(theFellowshipOfTheRing, theTwoTowers, theReturnOfTheKing); assertThat(elvesRings).isNotEmpty().hasSize(3); - assertThat(elvesRings).hasSameSizeAs(trilogy); - assertThat(elvesRings).hasSameSizeAs(newArrayList(trilogy)); + assertThat(elvesRings) + .hasSameSizeAs(trilogy) + .hasSameSizeAs(newArrayList(trilogy)); assertThat(elvesRings).contains(nenya).doesNotContain(oneRing); - assertThat(elvesRings).containsExactly(vilya, nenya, narya); - assertThat(elvesRings).containsExactlyElementsOf(newArrayList(vilya, nenya, narya)); + assertThat(elvesRings) + .containsExactly(vilya, nenya, narya) + .containsExactlyElementsOf(newArrayList(vilya, nenya, narya)); // you can check element at a given index (we use Index.atIndex(int) synthetic sugar for better readability). assertThat(elvesRings).contains(vilya, atIndex(0)).contains(nenya, atIndex(1)).contains(narya, atIndex(2)); // with containsOnly, all the elements must be present (but the order is not important) - assertThat(elvesRings).containsOnly(nenya, vilya, narya); - assertThat(elvesRings).containsOnlyElementsOf(newArrayList(nenya, vilya, narya)); - assertThat(elvesRings).hasSameElementsAs(newArrayList(nenya, vilya, narya)); + assertThat(elvesRings) + .containsOnly(nenya, vilya, narya) + .containsOnlyElementsOf(newArrayList(nenya, vilya, narya)) + .hasSameElementsAs(newArrayList(nenya, vilya, narya)); assertThat(elvesRings).doesNotContainNull().doesNotHaveDuplicates(); assertThat(elvesRings).doesNotContainAnyElementsOf(newArrayList(oneRing, manRing, dwarfRing)); // special check for null, empty collection or both @@ -371,8 +374,9 @@ public void iterable_assertions_on_extracted_private_fields_values_example() { @Test public void array_assertions_testing_elements_type() throws Exception { Number[] numbers = { 2, 6L, 8.0 }; - assertThat(numbers).hasAtLeastOneElementOfType(Long.class); - assertThat(numbers).hasOnlyElementsOfType(Number.class); + assertThat(numbers) + .hasAtLeastOneElementOfType(Long.class) + .hasOnlyElementsOfType(Number.class); } @Test diff --git a/assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java b/assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java index cbbfd74d..c07fe77d 100644 --- a/assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java +++ b/assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java @@ -116,8 +116,9 @@ public void isSame_isNotSame_assertions_examples() { @Test public void isIn_isNotIn_assertions_examples() { - assertThat(frodo).isIn(fellowshipOfTheRing); - assertThat(frodo).isIn(sam, frodo, pippin); + assertThat(frodo) + .isIn(fellowshipOfTheRing) + .isIn(sam, frodo, pippin); assertThat((TolkienCharacter) null).isIn(sam, frodo, pippin, null); assertThat(sauron).isNotIn(fellowshipOfTheRing); assertThat((TolkienCharacter) null).isNotIn(fellowshipOfTheRing); @@ -212,13 +213,13 @@ public void should_be_able_to_extract_primitive_values() { @Test public void has_field_or_property_examples() { - assertThat(frodo).hasFieldOrProperty("age"); - // private field are found unless Assertions.setAllowExtractingPrivateFields(false); - assertThat(frodo).hasFieldOrProperty("notAccessibleField"); - assertThat(frodo).hasFieldOrPropertyWithValue("age", 33); - assertThat(frodo).hasFieldOrProperty("race.name"); - assertThat(frodo).hasOnlyFields("age", "race", "name", "notAccessibleField"); - assertThat(frodo).hasFieldOrPropertyWithValue("race.name", "Hobbit"); + assertThat(frodo) + .hasFieldOrProperty("age") + .hasFieldOrProperty("notAccessibleField") + .hasFieldOrPropertyWithValue("age", 33) + .hasFieldOrProperty("race.name") + .hasOnlyFields("age", "race", "name", "notAccessibleField") + .hasFieldOrPropertyWithValue("race.name", "Hobbit"); } @Test diff --git a/assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java b/assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java index f8855270..af465af5 100644 --- a/assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java +++ b/assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java @@ -104,8 +104,9 @@ public void iterable_basic_assertions_examples() { .isSubsetOf(duplicatedElvesRings); try { - assertThat(elvesRings).isSubsetOf(list(vilya, nenya, vilya, oneRing)); - assertThat(elvesRings).containsOnly(nenya, vilya, oneRing); + assertThat(elvesRings) + .isSubsetOf(list(vilya, nenya, vilya, oneRing)) + .containsOnly(nenya, vilya, oneRing); } catch (AssertionError e) { logAssertionErrorMessage("containsOnly", e); } @@ -324,8 +325,9 @@ public void narrow_assertions_type_with_asInstanceOf_example() { @Test public void iterable_is_subset_of_assertion_example() { Collection elvesRings = list(vilya, nenya, narya); - assertThat(elvesRings).isSubsetOf(ringsOfPower); - assertThat(elvesRings).isSubsetOf(vilya, nenya, narya); + assertThat(elvesRings) + .isSubsetOf(ringsOfPower) + .isSubsetOf(vilya, nenya, narya); try { assertThat(elvesRings).isSubsetOf(list(nenya, narya)); } catch (AssertionError e) { @@ -442,17 +444,16 @@ public void iterable_assertion_match_example() { @Test public void iterable_satisfy_assertion_example() { List hobbits = list(frodo, sam, pippin); - assertThat(hobbits).allSatisfy(character -> { + assertThat(hobbits) + .allSatisfy(character -> { assertThat(character.getRace()).isEqualTo(HOBBIT); assertThat(character.getName()).isNotEqualTo("Sauron"); - }); - - assertThat(hobbits).anySatisfy(character -> { + }) + .anySatisfy(character -> { assertThat(character.getRace()).isEqualTo(HOBBIT); assertThat(character.age).isLessThan(30); - }); - - assertThat(hobbits).noneSatisfy(character -> assertThat(character.getRace()).isEqualTo(ELF)); + }) + .noneSatisfy(character -> assertThat(character.getRace()).isEqualTo(ELF)); // order is important, so frodo must satisfy the first lambda requirements, sam the second and pippin the last assertThat(hobbits).satisfiesExactly(character -> assertThat(character.getName()).isEqualTo("Frodo"), @@ -599,12 +600,14 @@ public void iterable_assertions_on_flat_extracted_values_examples() throws Excep public void iterable_assertions_testing_elements_type() throws Exception { List numbers = list(1L, 2L); - assertThat(numbers).hasOnlyElementsOfType(Number.class); - assertThat(numbers).hasOnlyElementsOfType(Long.class); + assertThat(numbers) + .hasOnlyElementsOfType(Number.class) + .hasOnlyElementsOfType(Long.class); List mixed = list("string", 1L); - assertThat(mixed).hasAtLeastOneElementOfType(String.class); - assertThat(mixed).hasOnlyElementsOfTypes(Long.class, String.class); + assertThat(mixed) + .hasAtLeastOneElementOfType(String.class) + .hasOnlyElementsOfTypes(Long.class, String.class); } @Test @@ -769,9 +772,10 @@ public void zipStatisfy_example() { public void should_not_produce_warning_for_varargs_parameter() { List> list = new ArrayList<>(); list.add(Pair.of("A", "B")); - assertThat(list).containsAnyOf(Pair.of("A", "B"), Pair.of("C", "D")); - assertThat(list).containsExactly(Pair.of("A", "B")); - assertThat(list).contains(Pair.of("A", "B")); + assertThat(list) + .containsAnyOf(Pair.of("A", "B"), Pair.of("C", "D")) + .containsExactly(Pair.of("A", "B")) + .contains(Pair.of("A", "B")); } @Test diff --git a/assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java b/assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java index 0e458046..00e2396b 100644 --- a/assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java +++ b/assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java @@ -64,29 +64,29 @@ public void map_assertions_examples() { // note the usage of Assertions.entry(key, value) synthetic sugar for better readability (similar to // MapEntry.entry(key, value)). - assertThat(ringBearers).contains(entry(oneRing, frodo), entry(nenya, galadriel)); - // using java util Map.Entry - assertThat(ringBearers).contains(javaMapEntry(oneRing, frodo), javaMapEntry(nenya, galadriel)); + assertThat(ringBearers) + .contains(entry(oneRing, frodo), entry(nenya, galadriel)) + .contains(javaMapEntry(oneRing, frodo), javaMapEntry(nenya, galadriel)); // same assertion but different way of expressing it : no entry call needed but no varargs support. assertThat(ringBearers).containsEntry(oneRing, frodo).containsEntry(nenya, galadriel); // opposite of contains/containsEntry - assertThat(ringBearers).doesNotContain(entry(oneRing, sauron), entry(nenya, aragorn)); - assertThat(ringBearers).doesNotContainEntry(oneRing, aragorn); + assertThat(ringBearers) + .doesNotContain(entry(oneRing, sauron), entry(nenya, aragorn)) + .doesNotContainEntry(oneRing, aragorn); Map ringBearersInDifferentOrder = new LinkedHashMap<>(); ringBearersInDifferentOrder.put(Ring.oneRing, frodo); ringBearersInDifferentOrder.put(Ring.narya, gandalf); ringBearersInDifferentOrder.put(Ring.nenya, galadriel); ringBearersInDifferentOrder.put(Ring.vilya, elrond); - assertThat(ringBearers).containsExactlyInAnyOrderEntriesOf(ringBearersInDifferentOrder); - - // Assertion on key - assertThat(ringBearers).containsKey(nenya); - assertThat(ringBearers).containsKeys(nenya, narya); - assertThat(ringBearers).containsValues(frodo, galadriel); - assertThat(ringBearers).containsOnlyKeys(nenya, narya, vilya, oneRing); - assertThat(ringBearers).doesNotContainKey(manRing); - assertThat(ringBearers).doesNotContainKeys(manRing, dwarfRing); + assertThat(ringBearers) + .containsExactlyInAnyOrderEntriesOf(ringBearersInDifferentOrder) + .containsKey(nenya) + .containsKeys(nenya, narya) + .containsValues(frodo, galadriel) + .containsOnlyKeys(nenya, narya, vilya, oneRing) + .doesNotContainKey(manRing) + .doesNotContainKeys(manRing, dwarfRing); try { assertThat(ringBearers).containsOnlyKeys(nenya, narya, dwarfRing); @@ -95,13 +95,14 @@ public void map_assertions_examples() { } // Assertion on value - assertThat(ringBearers).containsValue(frodo); - assertThat(ringBearers).doesNotContainValue(sam); - - assertThat(ringBearers).hasSameSizeAs(ringBearers); + assertThat(ringBearers) + .containsValue(frodo) + .doesNotContainValue(sam) + .hasSameSizeAs(ringBearers); ringBearers.clear(); - assertThat(ringBearers).contains(); - assertThat(ringBearers).containsAllEntriesOf(ringBearers); + assertThat(ringBearers) + .contains() + .containsAllEntriesOf(ringBearers); } @Test @@ -222,10 +223,11 @@ public void map_with_condition_examples() { ringBearers.put(frodo, oneRing); ringBearers.put(isildur, oneRing); - assertThat(ringBearers).hasEntrySatisfying(oneRingManBearer); - assertThat(ringBearers).hasEntrySatisfying(isMan, oneRingBearer); - assertThat(ringBearers).hasKeySatisfying(isMan); - assertThat(ringBearers).hasValueSatisfying(oneRingBearer); + assertThat(ringBearers) + .hasEntrySatisfying(oneRingManBearer) + .hasEntrySatisfying(isMan, oneRingBearer) + .hasKeySatisfying(isMan) + .hasValueSatisfying(oneRingBearer); } @Test From ab69d549890ecff9f7261af76ad2c65e0e868601 Mon Sep 17 00:00:00 2001 From: Tim te Beek Date: Mon, 14 Apr 2025 22:57:04 +0200 Subject: [PATCH 2/2] Restore a few over eager collapsed statements --- .../examples/BasicAssertionsExamples.java | 5 ++-- .../examples/IterableAssertionsExamples.java | 29 ++++++++++--------- .../examples/MapAssertionsExamples.java | 7 +++-- 3 files changed, 24 insertions(+), 17 deletions(-) diff --git a/assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java b/assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java index c07fe77d..b509edea 100644 --- a/assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java +++ b/assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java @@ -213,9 +213,10 @@ public void should_be_able_to_extract_primitive_values() { @Test public void has_field_or_property_examples() { + assertThat(frodo).hasFieldOrProperty("age"); + // private field is found unless Assertions.setAllowExtractingPrivateFields(false); + assertThat(frodo).hasFieldOrProperty("notAccessibleField"); assertThat(frodo) - .hasFieldOrProperty("age") - .hasFieldOrProperty("notAccessibleField") .hasFieldOrPropertyWithValue("age", 33) .hasFieldOrProperty("race.name") .hasOnlyFields("age", "race", "name", "notAccessibleField") diff --git a/assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java b/assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java index af465af5..df273edf 100644 --- a/assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java +++ b/assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java @@ -446,23 +446,26 @@ public void iterable_satisfy_assertion_example() { List hobbits = list(frodo, sam, pippin); assertThat(hobbits) .allSatisfy(character -> { - assertThat(character.getRace()).isEqualTo(HOBBIT); - assertThat(character.getName()).isNotEqualTo("Sauron"); - }) + assertThat(character.getRace()).isEqualTo(HOBBIT); + assertThat(character.getName()).isNotEqualTo("Sauron"); + }) .anySatisfy(character -> { - assertThat(character.getRace()).isEqualTo(HOBBIT); - assertThat(character.age).isLessThan(30); - }) + assertThat(character.getRace()).isEqualTo(HOBBIT); + assertThat(character.age).isLessThan(30); + }) .noneSatisfy(character -> assertThat(character.getRace()).isEqualTo(ELF)); // order is important, so frodo must satisfy the first lambda requirements, sam the second and pippin the last - assertThat(hobbits).satisfiesExactly(character -> assertThat(character.getName()).isEqualTo("Frodo"), - character -> assertThat(character.getName()).isEqualTo("Sam"), - character -> assertThat(character.getName()).startsWith("Pip")) - // order is not but all requirements must be met - .satisfiesExactlyInAnyOrder(character -> assertThat(character.getName()).isEqualTo("Sam"), - character -> assertThat(character.getName()).startsWith("Pip"), - character -> assertThat(character.getName()).isEqualTo("Frodo")); + assertThat(hobbits) + .satisfiesExactly( + character -> assertThat(character.getName()).isEqualTo("Frodo"), + character -> assertThat(character.getName()).isEqualTo("Sam"), + character -> assertThat(character.getName()).startsWith("Pip")) + // order is not but all requirements must be met + .satisfiesExactlyInAnyOrder( + character -> assertThat(character.getName()).isEqualTo("Sam"), + character -> assertThat(character.getName()).startsWith("Pip"), + character -> assertThat(character.getName()).isEqualTo("Frodo")); } @Test diff --git a/assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java b/assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java index 00e2396b..9a2190fc 100644 --- a/assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java +++ b/assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java @@ -63,9 +63,10 @@ public void map_assertions_examples() { assertThat(ringBearers).isNotEmpty().hasSize(4); // note the usage of Assertions.entry(key, value) synthetic sugar for better readability (similar to - // MapEntry.entry(key, value)). assertThat(ringBearers) + // MapEntry.entry(key, value)). .contains(entry(oneRing, frodo), entry(nenya, galadriel)) + // using java util Map.Entry .contains(javaMapEntry(oneRing, frodo), javaMapEntry(nenya, galadriel)); // same assertion but different way of expressing it : no entry call needed but no varargs support. assertThat(ringBearers).containsEntry(oneRing, frodo).containsEntry(nenya, galadriel); @@ -79,8 +80,10 @@ public void map_assertions_examples() { ringBearersInDifferentOrder.put(Ring.narya, gandalf); ringBearersInDifferentOrder.put(Ring.nenya, galadriel); ringBearersInDifferentOrder.put(Ring.vilya, elrond); + assertThat(ringBearers).containsExactlyInAnyOrderEntriesOf(ringBearersInDifferentOrder); + + // Assertion on key assertThat(ringBearers) - .containsExactlyInAnyOrderEntriesOf(ringBearersInDifferentOrder) .containsKey(nenya) .containsKeys(nenya, narya) .containsValues(frodo, galadriel)