Write Cleaner and Faster Unit Tests with AssertJ as a Java Developer

Ever found yourself staring at your unit tests, wondering if there's a better way to write them? You know, something that's more readable, more intuitive, and doesn't make your code look like a puzzle? Well, I've got some good news for you!

In this guide, we're going to dive into AssertJ, a game-changing testing library that will make your life as a Java developer so much easier.

What is AssertJ?

AssertJ is a Java library that provides a rich set of assertions with a fluent API, making your test code more readable and maintainable. It allows you to chain assertions, provides helpful error messages, and offers specialized assertions for different types of objects including collections, strings, files, and more.

Why Java Developers Love Using AssertJ

There's a reason AssertJ has become so popular in the Java testing ecosystem:

The fluent API is a true game-changer. Rather than writing separate, disconnected assertions, you can chain them together in a way that flows like natural language. This makes your tests not only easier to write, but also more understandable when you revisit them months later.

Error messages in AssertJ are incredibly detailed and helpful. When an assertion fails, you get comprehensive information about what went wrong, making debugging much faster.

The auto-completion support is fantastic too. Once you type assertThat(), your IDE shows you all the available assertions specific to the type you're testing. No more guessing or searching for documentation!

How to Use AssertJ

Let's dive into some practical examples to see AssertJ in action. I'll show you how to use it in real-world scenarios.

Basic Assertions

First, you'll need to add AssertJ to your project:

// If you're using Maven
<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <version>3.24.2</version>
    <scope>test</scope>
</dependency>

Now, let's look at some basic assertions:

import static org.assertj.core.api.Assertions.*;

public class UserTest {
    @Test
    public void testUserCreation() {
        User user = new User("John", "Doe", 30);

        // String assertions
        assertThat(user.getFirstName()).isEqualTo("John")
          .startsWith("J")
          .isNotEmpty();

        // Number assertions
        assertThat(user.getAge()).isPositive()
          .isLessThan(100)
          .isGreaterThanOrEqualTo(18);

        // Object assertions
        assertThat(user).isNotNull()
          .hasFieldOrPropertyWithValue("lastName", "Doe");
    }
}

Notice how we can chain multiple assertions together? This makes your tests more concise and readable.

List Assertions

Testing collections is where AssertJ really shines. Let's say we have a shopping cart with items:

@Test
public void testShoppingCart() {
    List<Product> cart = shoppingService.getUserCart(userId);

    assertThat(cart).isNotNull()
       .isNotEmpty()
       .hasSize(3)
       .contains(new Product("Laptop", 1200.00))
       .doesNotContain(new Product("Printer", 299.99));

    // Extract and test properties from all items
    assertThat(cart).extracting("name")
      .contains("Laptop", "Mouse", "Keyboard")
      .doesNotContain("Monitor");

    // Test that all items satisfy a condition
    assertThat(cart).allMatch(product -> product.getPrice() > 0)
                    .anyMatch(product -> product.getPrice() > 1000);
}

The extracting method is particularly powerful - it lets you pull out a specific property from all objects in the collection and make assertions on those values.

Conditional Assertions

Sometimes you need to make assertions only under certain conditions. AssertJ has you covered:

@Test
public void testPaymentProcessing() {
    PaymentResult result = paymentService.processPayment(new Payment(100.00, "USD"));

    // Only verify the transaction ID if the payment was successful
    assertThat(result).satisfies(r -> {
        if (r.isSuccessful()) {
            assertThat(r.getTransactionId()).isNotEmpty().hasSize(36); // UUID length
            assertThat(r.getProcessedTime()).isNotNull().isCloseTo(
                LocalDateTime.now(), within(1, ChronoUnit.MINUTES));
        } else {
            assertThat(r.getErrorCode()).isNotNull();
            assertThat(r.getErrorMessage()).isNotEmpty();
        }
    });
}

The satisfies method lets you apply a consumer with custom logic, making your assertions as flexible as you need them to be.

Stream Assertions

When testing your Java applications, you'll often need to verify collections of objects. Converting your lists to streams and using AssertJ's stream assertions gives you powerful, fluent ways to verify your data. Let's walk through a comprehensive example.

First, let's create a simple Product class for our example:

public class Product {
    private String name;
    private double price;
    private String category;
    private boolean inStock;

    // Constructor, getters, setters, equals/hashCode omitted for brevity
}

Now, let's see how to convert a list to a stream and leverage AssertJ's stream assertions:

import static org.assertj.core.api.Assertions.*;
import java.util.List;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;

public class ProductStreamTest {

    @Test
    public void testProductStream() {
        // Given: a list of products
        List<Product> products = List.of(
            new Product("Laptop", 1299.99, "Electronics", true),
            new Product("Phone", 899.99, "Electronics", true),
            new Product("Headphones", 199.99, "Electronics", true),
            new Product("Desk", 349.99, "Furniture", false),
            new Product("Chair", 249.99, "Furniture", true)
        );

        // When: converting the list to a stream
        Stream<Product> productStream = products.stream();

        // Then: verify the stream using AssertJ
        assertThat(productStream)
            // Basic stream assertions
            .isNotNull()                    // Stream is not null
            .isNotEmpty()                   // Stream has elements
            .hasSize(5)                     // Stream contains 5 elements

            // Content verification
            .contains(new Product("Laptop", 1299.99, "Electronics", true))  // Contains specific product
            .doesNotContain(new Product("Table", 399.99, "Furniture", true)) // Doesn't contain this product

            // Recreate stream as the previous one was consumed
            .asList()                        // Convert back to list to get a fresh stream for more assertions
            .stream()

            // Element matching
            .anyMatch(p -> p.getPrice() > 1000)    // At least one product costs more than $1000
            .allMatch(p -> p.getPrice() > 0)       // All products have positive prices
            .noneMatch(p -> p.getPrice() > 2000);  // No product costs more than $2000

        // Create a new stream for more assertions
        Stream<Product> newProductStream = products.stream();

        // Property extraction
        assertThat(newProductStream)
            .extracting("category")              // Extract the category property
            .contains("Electronics", "Furniture") // Contains these categories
            .doesNotContain("Clothing")          // Doesn't contain this category
            .hasSize(5);                         // Total of 5 category values

        // Create a new stream again
        newProductStream = products.stream();

        // Multiple property extraction
        assertThat(newProductStream)
            .extracting("name", "price")         // Extract multiple properties as tuples
            .contains(                           // Verify specific tuples exist
                tuple("Laptop", 1299.99),
                tuple("Phone", 899.99)
            );

        // Create a new stream
        newProductStream = products.stream();

        // Filtering streams before assertion
        assertThat(newProductStream)
            .filteredOn("category", "Electronics")  // Filter by category
            .hasSize(3)                             // 3 electronics products
            .extracting("name")                     // Extract names of filtered products
            .containsExactlyInAnyOrder("Laptop", "Phone", "Headphones");

        // Create a new stream
        newProductStream = products.stream();

        // Filtering with predicates
        assertThat(newProductStream)
            .filteredOn(p -> p.getPrice() < 300)    // Filter by predicate (products under $300)
            .hasSize(2)                             // 2 products under $300
            .extracting("name")                     // Get their names
            .containsExactlyInAnyOrder("Headphones", "Chair");

        // Create a new stream
        newProductStream = products.stream();

        // Mapping operations
        assertThat(newProductStream)
            .map(Product::getName)                  // Map to product names
            .containsExactlyInAnyOrder("Laptop", "Phone", "Headphones", "Desk", "Chair")
            .allSatisfy(name -> {                   // Verify each name
                assertThat(name).isNotEmpty();
                assertThat(name.length()).isGreaterThan(3);
            });

        // Create a new stream for flatMap example
        Stream<List<Product>> streamOfLists = Stream.of(
            products.subList(0, 2),                 // First two products
            products.subList(2, 5)                  // Last three products
        );

        // FlatMap operation
        assertThat(streamOfLists)
            .flatMap(List::stream)                  // Flatten the stream of lists into a stream of products
            .hasSize(5)                             // Total of 5 products
            .extracting("name")                     // Extract names
            .containsExactlyInAnyOrder("Laptop", "Phone", "Headphones", "Desk", "Chair");

        // Create a new stream
        newProductStream = products.stream();

        // Element classification
        assertThat(newProductStream)
            .hasOnlyElementsOfType(Product.class)   // All elements are of type Product
            .asList()                           // Convert to list to create a new stream
            .stream()
            .extracting("price")                    // Extract prices
            .hasOnlyElementsOfType(Double.class);   // All prices are Double values

        // Create a new stream
        newProductStream = products.stream();

        // Grouped assertions on elements
        assertThat(newProductStream)
            .allSatisfy(product -> {  // Each product must satisfy these conditions
                assertThat(product.getName()).isNotEmpty();
                assertThat(product.getPrice()).isPositive();
                assertThat(product.getCategory()).isIn("Electronics", "Furniture");
            });
    }
}

This example demonstrates the main stream assertion capabilities in AssertJ:

1. Basic stream assertions: isNotNull(), isNotEmpty(), hasSize()
2. Content verification: contains(), doesNotContain()
3. Element matching: anyMatch(), allMatch(), noneMatch()
4. Property extraction: extracting() for single and multiple properties with tuple()
5. Filtering: filteredOn() with property name or predicate
6. Transformations: map(), flatMap()
7. Type verification: hasOnlyElementsOfType()
8. Element verification: allSatisfy(), containsExactlyInAnyOrder()

This powerful combination of Java streams and AssertJ gives you incredible flexibility in testing collections, making your tests more expressive and maintainable.

Key Takeaways

Let's recap what makes AssertJ so powerful for Java testing:

• Basic Assertions give you a richer vocabulary for expressing expectations. Instead of cryptic equality checks, you get meaningful methods like isEqualTo(), isNotEmpty(), and isGreaterThan() that make your tests self-documenting. The ability to chain assertions means fewer lines of code and clearer intent.
• List Assertions transform how you work with collections. Testing for size, content, order, and extracting properties becomes trivial. The expressiveness of methods like extracting(), filteredOn(), and containsExactlyInAnyOrder() means you spend less time writing test utility methods.
• Conditional Assertions add flexibility when you need branching logic in your tests. Using satisfies() or other conditional methods lets you handle different scenarios elegantly without resorting to multiple separate test methods or complex if-else structures.

The real magic of AssertJ is how it makes your tests more readable for humans while still being precise for machines. And when assertions fail, the detailed error messages help you quickly identify exactly what went wrong.