AssertJ’s Java 8 Features

1. Overview

This article focuses on AssertJ‘s Java8-related features and is the third article from the series.

If you’re looking for general information on its main features have a look at the first article in the series Introduction to AssertJ and then at AssertJ for Guava.

2. Maven Dependencies

Java 8’s support is included in the main AssertJ Core module since version 3.5.1. In order to use the module, you will need to include the following section in your pom.xml file:

<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <version>3.5.1</version>
    <scope>test</scope>
</dependency>

This dependency covers only the basic Java assertions. If you want to use the advanced assertions, you will need to add additional modules separately.

The latest Core version can be found here.

3. Java 8 Features

AssertJ leverages Java 8 features by providing special helper methods and new assertions for Java 8 types.

3.1. Optional Assertions

Let’s create a simple Optional instance:

Optional<String> givenOptional = Optional.of("something");

We can now easily check if an Optional contains some value and what that containing value is:

assertThat(givenOptional)
  .isPresent()
  .hasValue("something");

3.2. Predicate Assertions

Let’s create a simple Predicate instance by checking the length of a String:

Predicate<String> predicate = s -> s.length() > 4;

Now you can easily check which Strings are rejected or accepted by the Predicate:

assertThat(predicate)
  .accepts("aaaaa", "bbbbb")
  .rejects("a", "b")
  .acceptsAll(asList("aaaaa", "bbbbb"))
  .rejectsAll(asList("a", "b"));

3.3. LocalDate Assertions

Let’s start by defining two LocalDate objects:

LocalDate givenLocalDate = LocalDate.of(2016, 7, 8);
LocalDate todayDate = LocalDate.now();

You can now easily check if a given date is before/after a given date, or today:

assertThat(givenLocalDate)
  .isBefore(LocalDate.of(2020, 7, 8))
  .isAfterOrEqualTo(LocalDate.of(1989, 7, 8));

assertThat(todayDate)
  .isAfter(LocalDate.of(1989, 7, 8))
  .isToday();

3.4. LocalDateTime Assertions

The LocalDateTime assertions work similarly to LocalDate‘s, but do not share the isToday method.

Let’s create an example LocalDateTime object:

LocalDateTime givenLocalDate = LocalDateTime.of(2016, 7, 8, 12, 0);

And now you can check:

assertThat(givenLocalDate)
  .isBefore(LocalDateTime.of(2020, 7, 8, 11, 2));

3.5. LocalTime Assertions

The LocalTime assertions work similarly to other java.util.time.* assertions, but they do have one exclusive method: hasSameHourAs.

Let’s create an example LocalTime object:

LocalTime givenLocalTime = LocalTime.of(12, 15);

and now you can assert:

assertThat(givenLocalTime)
  .isAfter(LocalTime.of(1, 0))
  .hasSameHourAs(LocalTime.of(12, 0));

3.6. FlatExtracting Helper Method

The FlatExtracting is a special utility method that utilizes Java 8’s lambdas in order to extract properties from Iterable elements.

Let’s create a simple List with LocalDate objects:

List<LocalDate> givenList = asList(ofYearDay(2016, 5), ofYearDay(2015, 6));

now we can easily check if this List contains at least one LocalDate object with the year 2015:

assertThat(givenList)
  .flatExtracting(LocalDate::getYear)
  .contains(2015);

the flatExtracting method does not limit us to field extraction. We can always provide it with any function:

assertThat(givenList)
  .flatExtracting(LocalDate::isLeapYear)
  .contains(true);

or even:

assertThat(givenList)
  .flatExtracting(Object::getClass)
  .contains(LocalDate.class);

You can also extract multiple properties at once:

assertThat(givenList)
  .flatExtracting(LocalDate::getYear, LocalDate::getDayOfMonth)
  .contains(2015, 6);

3.7. Satisfies Helper Method

The Satisfies method allows you to quickly check if an object satisfies all provided assertions.

Let’s create an example String instance:

String givenString = "someString";

and now we can provide assertions as a lambda body:

assertThat(givenString)
  .satisfies(s -> {
    assertThat(s).isNotEmpty();
    assertThat(s).hasSize(10);
  });

3.8. HasOnlyOneElementSatisfying Helper Method

The HasOnlyOneElement helper method allows checking if an Iterable instance contains exactly only one element satisfying provided assertions.

Let’s create an example List:

List<String> givenList = Arrays.asList("");

and now you can assert:

assertThat(givenList)
  .hasOnlyOneElementSatisfying(s -> assertThat(s).isEmpty());

3.9. Matches Helper Method

The Matches helper method allows checking if a given object matches the given Predicate function.

Let’s take an empty String:

String emptyString = "";

and now we can check it’s state by providing an adequate Predicate lambda function:

assertThat(emptyString)
  .matches(String::isEmpty);

4. Conclusion

In this last article from the AssertJ series, we explored all advanced AssertJ Java 8’s features, which concludes the series.

The implementation of all the examples and code snippets can be found in the GitHub project.