AssertJ is a library that simplifies writing assertions in tests by providing a fluent API that focuses on readability. It can be added to a Maven project as a dependency. AssertJ makes assertions more readable by providing descriptive error messages. It supports filtering collections and arrays, extracting values, assertions on optional values, and other features like soft assertions and string assertions on file contents.

1. AssertJ
Quick introduction

2. What is it?
Library to simplify assertions in tests
Forked from fest-assert: actively maintained
Focus on improving readability through its fluent API: IDE friendly

3. How to use?
Add Maven dependency (already on parent/pom.xml):
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
<version>3.2.0</version> <!-- Not needed on common-uber sub-projects -->
<scope>test</scope> <!-- Not needed on common-uber sub-projects -->
</dependency>
Add static import to Eclipse:
1. Go to : Preferences > Java > Editor > Content assist > Favorites > New Type
2. Enter : org.assertj.core.api.Assertions
3. You should see : org.assertj.core.api.Assertions.* in the list.

4. Simple assertions
// AssertJ
Assertions.assertThat(retrievedStore)
.isNotNull();
Assertions.assertThat(retrievedStore.name)
.isEqualTo(dbStore.getName());
Assertions.assertThat(retrievedStore.isMobileOptimized)
.isTrue();
Assertions.assertThat(detailReport.getEntries())
.as("Detail report %s entries", countryCode)
.isNotNull().hasSize(5);
// Hamcrest
MatcherAssert.assertThat(retrievedStore,
Matchers.is(Matchers.notNullValue()));
MatcherAssert.assertThat(retrievedStore.name,
Matchers.equalTo(dbStore.getName()));
MatcherAssert.assertThat(retrievedStore.isMobileOptimized,
Matchers.is(true));
MatcherAssert.assertThat(detailReport.getEntries(),
Matchers.is(Matchers.notNullValue()));
MatcherAssert.assertThat(detailReport.getEntries(),
Matchers.hasSize(5));

5. Friendly and comprehensive error messages
// AssertJ - Strings comparison
Assertions.assertThat("The quick brown fox jump over the
lazy dog").isEqualTo("The quick brown fox jumps over the
lazy dog");
expected:<...quick brown fox jump[s] over the lazy dog"> but
was:<...quick brown fox jump[] over the lazy dog">
// Hamcrest - Strings comparison
MatcherAssert.assertThat("The quick brown fox jump over the
lazy dog", Matchers.equalTo("The quick brown fox jumps over
the lazy dog"));
Expected: "The quick brown fox jumps over the lazy dog"
but: was "The quick brown fox jump over the lazy dog"
// Hamcrest - List elements comparison
MatcherAssert.assertThat(Arrays.asList(1, 2, 3, 4, 5),
Matchers.hasItems(5, 7));
Expected: (a collection containing <5> and a collection
containing <7>)
but: a collection containing <7> mismatches were: [was
<1>, was <2>, was <3>, was <4>, was <5>]
// AssertJ - List elements comparison
Assertions.assertThat(Arrays.asList(1, 2, 3, 4,
5)).contains(5, 7);
Expecting:
<[1, 2, 3, 4, 5]>
to contain:
<[5, 7]>
but could not find:
<[7]>

6. Filtering and assertions on iterables or arrays
// AssertJ
// Filter uses introspection to get property/field value
Assertions.assertThat(fellowshipOfTheRing)
.filteredOn("race", HOBBIT)
.containsOnly(sam, frodo, pippin, merry);
// Nested properties are supported
Assertions.assertThat(fellowshipOfTheRing)
.filteredOn("race.name", "Man")
.containsOnly(aragorn, boromir);
// Chaining multiple filter criteria
Assertions.assertThat(fellowshipOfTheRing)
.filteredOn("race", MAN)
.filteredOn("name", not("Boromir"))
.containsOnly(aragorn);
// Hamcrest
// Not even fair… you have to do it manually =/
List<TolkienCharacter> fellowshipHobbits =
fellowshipOfTheRing.stream()
.filter(c -> c.getRace().equals(Race.HOBBIT))
.collect(Collectors.toList());
MatcherAssert.assertThat(fellowshipHobbits,
Matchers.contains(sam, frodo, pippin, merry));
// No containsOnly

7. Filtering and assertions on iterables or arrays (cont.)
// AssertJ
// WesterosHouse class has a method: public String sayTheWords()
List<WesterosHouse> greatHouses = new ArrayList<>();
greatHouses.add(new WesterosHouse("Stark", "Winter is Coming"));
greatHouses.add(new WesterosHouse("Lannister", "Hear Me Roar!"));
greatHouses.add(new WesterosHouse("Greyjoy", "We Do Not Sow"));
greatHouses.add(new WesterosHouse("Baratheon", "Our is the Fury"));
greatHouses.add(new WesterosHouse("Martell", "Unbowed, Unbent, Unbroken"));
greatHouses.add(new WesterosHouse("Tyrell", "Growing Strong"));
// let's verify the words of great houses in Westeros:
Assertions.assertThat(greatHouses).extractingResultOf("sayTheWords")
.contains("Winter is Coming", "We Do Not Sow", "Hear Me Roar!")
.doesNotContain("Lannisters always pay their debts");

8. Friendly exceptions/throwables testing
// Hamcrest
// Given
Long inexistentStoreId = 999L;
try {
// When
this.repository.retrieve(inexistentStoreId);
Assert.fail();
}
catch (NoSuchElementException e) {
// Then
assertThat(e.getMessage(),
containsString("Store ID '999' does not exist"));
}
// AssertJ
// Given
Long inexistentStoreId = 999L;
// When - Then
assertThatThrownBy(() -> repository.retrieve(inexistentStoreId))
.isInstanceOf(NoSuchElementException.class)
.hasMessageContaining("Store ID '999' does not exist");

9. Java 8 Support: Time API
// AssertJ
LocalDate firstOfJanuary2000 =
LocalDate.parse("2000-01-01");
// AssertJ converts String parameters to LocalDate
// to ease writing expected LocalDate
Assertions.assertThat(firstOfJanuary2000)
.isEqualTo("2000-01-01");
Assertions.assertThat(firstOfJanuary2000)
.isAfter("1999-12-31")
.isAfterOrEqualTo("1999-12-31")
.isAfterOrEqualTo("2000-01-01");
// Hamcrest - using third-party extension:
// org.exparity:hamcrest-date
LocalDate firstOfJanuary2000 =
LocalDate.parse("2000-01-01");
MatcherAssert.assertThat(firstOfJanuary2000,
Matchers.equalTo(LocalDate.parse("2000-01-01")));
MatcherAssert.assertThat(firstOfJanuary2000,
LocalDateMatchers.after(
LocalDate.parse("1999-12-31")));
// No afterOrEqual matcher

10. Java 8 Support: Optionals
// AssertJ
// optional with value
Optional<String> optional = Optional.of("Test");
Assertions.assertThat(optional)
.isPresent().contains("Test");
// empty optional
Optional<Object> emptyOptional = Optional.empty();
Assertions.assertThat(emptyOptional).isEmpty();
// Hamcrest
// optional with value
Optional<String> optional = Optional.of("Test");
MatcherAssert.assertThat(optional.isPresent(),
Matchers.is(true));
MatcherAssert.assertThat(optional.get(),
Matchers.equalTo("Test"));
// empty optional
Optional<Object> emptyOptional = Optional.empty();
MatcherAssert.assertThat(emptyOptional,
Matchers.equalTo(Optional.<Object> empty()));

11. Other features
Assertions on extracted fields/properties
extracts properties from iterable elements for assertions
Soft assertions
collect all assertions instead of stopping at the first one
String assertions on file contents
no need to manually read the file (useful for small files)
Flat(map) extracting
flatten a collection by extracting a field from it

12. Questions?
Thanks!