Skip to content

Collapse consecutive assertThat statements using the same object #65

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Apr 14, 2025
Merged

Collapse consecutive assertThat statements using the same object #65

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
f185b08
refactor: Collapse consecutive `assertThat` statements
timtebeek Apr 14, 2025
ab69d54
Restore a few over eager collapsed statements
timtebeek Apr 14, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
22 changes: 13 additions & 9 deletions assertions-examples/src/test/java/org/assertj/examples/ArrayAssertionsExamples.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down
16 changes: 9 additions & 7 deletions assertions-examples/src/test/java/org/assertj/examples/BasicAssertionsExamples.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down Expand Up @@ -213,12 +214,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);
// private field is 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)
.hasFieldOrPropertyWithValue("age", 33)
.hasFieldOrProperty("race.name")
.hasOnlyFields("age", "race", "name", "notAccessibleField")
.hasFieldOrPropertyWithValue("race.name", "Hobbit");
}

@Test
Expand Down
65 changes: 36 additions & 29 deletions assertions-examples/src/test/java/org/assertj/examples/IterableAssertionsExamples.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
}
Expand Down Expand Up @@ -324,8 +325,9 @@ public void narrow_assertions_type_with_asInstanceOf_example() {
@Test
public void iterable_is_subset_of_assertion_example() {
Collection<Ring> 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) {
Expand Down Expand Up @@ -442,26 +444,28 @@ public void iterable_assertion_match_example() {
@Test
public void iterable_satisfy_assertion_example() {
List<TolkienCharacter> hobbits = list(frodo, sam, pippin);
assertThat(hobbits).allSatisfy(character -> {
assertThat(character.getRace()).isEqualTo(HOBBIT);
assertThat(character.getName()).isNotEqualTo("Sauron");
});

assertThat(hobbits).anySatisfy(character -> {
assertThat(character.getRace()).isEqualTo(HOBBIT);
assertThat(character.age).isLessThan(30);
});

assertThat(hobbits).noneSatisfy(character -> assertThat(character.getRace()).isEqualTo(ELF));
assertThat(hobbits)
.allSatisfy(character -> {
assertThat(character.getRace()).isEqualTo(HOBBIT);
assertThat(character.getName()).isNotEqualTo("Sauron");
})
.anySatisfy(character -> {
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
Expand Down Expand Up @@ -599,12 +603,14 @@ public void iterable_assertions_on_flat_extracted_values_examples() throws Excep
public void iterable_assertions_testing_elements_type() throws Exception {
List<Long> numbers = list(1L, 2L);

assertThat(numbers).hasOnlyElementsOfType(Number.class);
assertThat(numbers).hasOnlyElementsOfType(Long.class);
assertThat(numbers)
.hasOnlyElementsOfType(Number.class)
.hasOnlyElementsOfType(Long.class);

List<? extends Object> 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
Expand Down Expand Up @@ -769,9 +775,10 @@ public void zipStatisfy_example() {
public void should_not_produce_warning_for_varargs_parameter() {
List<Entry<String, String>> 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
Expand Down
49 changes: 27 additions & 22 deletions assertions-examples/src/test/java/org/assertj/examples/MapAssertionsExamples.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -63,15 +63,17 @@ 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).contains(entry(oneRing, frodo), entry(nenya, galadriel));
// using java util Map.Entry
assertThat(ringBearers).contains(javaMapEntry(oneRing, frodo), javaMapEntry(nenya, galadriel));
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);
// 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<Ring, TolkienCharacter> ringBearersInDifferentOrder = new LinkedHashMap<>();
ringBearersInDifferentOrder.put(Ring.oneRing, frodo);
Expand All @@ -81,12 +83,13 @@ public void map_assertions_examples() {
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)
.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);
Expand All @@ -95,13 +98,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
Expand Down Expand Up @@ -222,10 +226,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
Expand Down