Unleash the Power of AssertJ: Make Your Unit Tests Crystal Clear

Unit tests are the superheroes of the coding world, ensuring your code works as intended. But writing clear and concise unit tests can sometimes feel like a challenge. Here’s where AssertJ swoops in to save the day! AssertJ is a fantastic framework for writing unit tests in Java, making them easy to understand and maintain.

This article will unveil a few secret weapons (or should we say, tips and tricks) to empower you with AssertJ. We’ll explore practical examples, showing you how to write clear and effective unit tests that will make you a testing rockstar!

1. Setting Up AssertJ

Before diving into the tips and tricks, let’s ensure we have AssertJ included in our project. Here’s how:

Using Maven:

1. Add the following dependency to your pom.xml file within the <dependencies> section:

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

2. Update your project dependencies (specific steps may vary based on your IDE).

Using Gradle:

1. Add the following dependency to your build.gradle file:

dependencies {
  testCompile 'org.assertj:assertj-core:3.4.1'  // Adjust version as needed
}

2. Sync your Gradle project.

Now AssertJ is ready to be used in your unit tests!

These are basic examples using Maven and Gradle. Refer to the official documentation for detailed instructions on including AssertJ in your specific project setup (https://github.com/assertj/assertj).

Below we will showcase some tips along with code snippets for better clarification

Tip #1: Clear and Readable Assertions with AssertJ

Traditional unit testing in Java often relies on methods like assertEquals or assertTrue from the junit.framework package. While they work, these methods can sometimes lead to less readable and maintainable tests.

AssertJ offers a more user-friendly approach with clear and concise methods for assertions. Here’s how it simplifies things:

What to Avoid:

• Long and Opaque Assertions: Traditional methods often require complex expressions to verify complex conditions. This can make tests harder to understand.
• Magic Numbers: Using literal values directly in assertions can make tests less flexible and harder to maintain.

What to Use Instead:

• Self-Documenting Assertions: AssertJ methods like isEqualTo, isNull, and isTrue are self-explanatory, making tests easier to read at a glance.
• Fluent API: AssertJ provides a fluent API that allows chaining assertions together, improving readability.

Let’s move on to an example demonstrating AssertJ for asserting objects and collections.

Object Assertions with AssertJ

Imagine a scenario where you’re testing a ShoppingCart class that holds items and calculates the total price.

Traditional Approach:

public class ShoppingCartTest {

  @Test
  public void testAddItem() {
    ShoppingCart cart = new ShoppingCart();
    Item item1 = new Item("Shirt", 20.0);
    
    cart.addItem(item1);
    
    // Traditional assertions can become cumbersome with complex objects
    assertTrue(cart.getItems().contains(item1));
    assertEquals(item1.getPrice(), cart.getTotalPrice(), 0.01);
  }
}

This approach works but can get verbose when dealing with object properties within nested assertions.

AssertJ Approach:

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

public class ShoppingCartTest {

  @Test
  public void testAddItem() {
    ShoppingCart cart = new ShoppingCart();
    Item item1 = new Item("Shirt", 20.0);
    
    cart.addItem(item1);
    
    assertThat(cart.getItems()).contains(item1);  // AssertJ for collections
    assertThat(cart.getTotalPrice()).isEqualTo(item1.getPrice(), within(0.01));
  }
}

The AssertJ version offers several improvements:

• Collection Assertions: assertThat(cart.getItems()).contains(item1) provides a clear way to assert the presence of an item in the cart.
• Matcher for Precision: within(0.01) is a matcher used with isEqualTo to allow for a slight difference due to potential floating-point calculations.

This example highlights how AssertJ helps with object and collection assertions, making your unit tests more concise and focused on the actual verification logic.

Tip #2: Powerful Matchers with AssertJ

AssertJ’s built-in matchers are a powerful tool for making complex assertions more readable and maintainable. They allow you to define specific conditions for what you expect from a value without resorting to cumbersome traditional methods.

What are Matchers?

Matchers are objects that encapsulate a specific assertion logic. They provide a more flexible and descriptive way to verify values compared to simple equality checks.

Benefits of Matchers:

• Improved Readability: Matchers often use natural language constructs, making tests easier to understand.
• Reusability: You can reuse matchers across different test cases.
• Flexibility: Matchers allow for complex assertions with a clear structure.

Common Built-in Matchers:

• containsString: Checks if a string contains a specific substring.
• hasSize: Verifies the size of a collection (e.g., number of elements in a list).
• startsWith: Asserts if a string starts with a specific prefix.

Demonstration:

Let’s consider a more complex scenario where we’re testing a service that generates personalized email greetings based on user information.

Example: User Greeting Service

Imagine a UserService that creates a greeting message for a user. The greeting should include the user’s name and a personalized message based on their age group.

Traditional Approach (Less Readable):

public class UserServiceTest {

  @Test
  public void testGenerateGreeting() {
    User user = new User("John Doe", 30);
    String greeting = userService.generateGreeting(user);
    
    assertTrue(greeting.contains(user.getName()));  // Less descriptive
    String expectedMessage;
    if (user.getAge() < 18) {
      expectedMessage = "Welcome, young adventurer!";
    } else {
      expectedMessage = "Hello, " + user.getName();
    }
    assertEquals(expectedMessage, greeting);  // Conditional logic can get messy
  }
}

This approach works but can become less readable with complex logic for different age groups.

AssertJ with Matchers:

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

public class UserServiceTest {

  @Test
  public void testGenerateGreeting() {
    User user = new User("John Doe", 30);
    String greeting = userService.generateGreeting(user);
    
    assertThat(greeting).containsString(user.getName());  // Clear and concise
    assertThat(greeting).startsWith("Hello, " + user.getName());  // Flexible assertion

    if (user.getAge() < 18) {
      assertThat(greeting).containsString("young adventurer!");
    }
  }
}

The AssertJ version offers several improvements:

• containsString Matcher: This matcher clearly expresses the expectation that the greeting contains the user’s name.
• startsWith Matcher: This matcher verifies that the greeting starts with a specific prefix based on the user’s name.
• Conditional Assertions: By leveraging conditional statements within the assertThat chain, the test remains focused on specific scenarios for different age groups.

This example demonstrates how matchers can simplify complex assertions while maintaining readability and clarity in your unit tests.

Tip #3: Custom Matchers for Specific Needs (Optional)

While AssertJ provides a rich set of built-in matchers, there might be situations where you need a more specific assertion logic tailored to your unique code. AssertJ allows you to create custom matchers to handle these scenarios.

Benefits of Custom Matchers:

• Encapsulation: Complex assertion logic can be encapsulated within a reusable custom matcher.
• Readability: Custom matchers can improve readability by providing a clear description of the intended assertion.

Creating a Custom Matcher:

Here’s a simplified example of creating a custom matcher to verify if a Product object has a discounted price:

public class DiscountedPriceMatcher implements Matcher<Product> {

  @Override
  public boolean matches(Product product) {
    return product.getPrice() < product.getRegularPrice();
  }

  @Override
  public String getDescription() {
    return "has a discounted price";
  }
}

Explanation:

• This custom matcher implements the Matcher interface from AssertJ.
• The matches method defines the logic for checking if a Product object has a discounted price (price lower than regular price).
• The getDescription method provides a human-readable description of the matcher’s purpose.

Using the Custom Matcher:

public class ProductServiceTest {

  @Test
  public void testApplyDiscount() {
    Product product = new Product("Shirt", 20.0, 15.0);
    
    productService.applyDiscount(product);
    
    assertThat(product).as("after applying discount").matches(new DiscountedPriceMatcher());
  }
}

Explanation:

• We create an instance of the DiscountedPriceMatcher.
• We use the matches method of assertThat with the custom matcher to verify if the product has a discounted price after applying the discount.
• The as method allows us to add a descriptive label to the assertion for improved readability.

This is a basic example, but it demonstrates how custom matchers can be created to handle specific assertion logic within your unit tests. Remember to consider the trade-off between complexity and reusability when creating custom matchers.

Tip #4: Leveraging AssertJ with Other Testing Frameworks (Optional)

AssertJ integrates seamlessly with popular testing frameworks like JUnit and Mockito. This allows you to leverage AssertJ’s clear assertions within your existing testing setup.

JUnit Integration:

JUnit doesn’t require any specific integration with AssertJ. You can directly use AssertJ’s methods within your JUnit test methods.

Example:

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

public class MathServiceTest {

  @Test
  public void testAdd() {
    MathService mathService = new MathService();
    int result = mathService.add(5, 3);
    
    assertThat(result).isEqualTo(8);
  }
}

In this example, we use AssertJ’s assertThat and isEqualTo methods within a JUnit test to verify the result of the add method in the MathService.

Mockito Integration:

Mockito is a popular mocking framework for creating mock objects in unit tests. AssertJ works well with Mockito to verify interactions with mocked objects.

Example:

import org.junit.Test;
import org.mockito.Mockito;
import static org.assertj.core.api.Assertions.*;

public class OrderServiceTest {

  @Test
  public void testPlaceOrder() {
    OrderService orderService = new OrderService();
    PaymentService mockPaymentService = Mockito.mock(PaymentService.class);
    orderService.setPaymentService(mockPaymentService);
    
    orderService.placeOrder(new Order());
    
    Mockito.verify(mockPaymentService).processPayment(Mockito.any());  // Mockito verification
    assertThat(mockPaymentService.getProcessedOrders()).hasSize(1);  // AssertJ for collections
  }
}

In this example, we use Mockito to mock the PaymentService and then use AssertJ’s methods to:

• Verify with Mockito that the processPayment method was called on the mock object.
• Assert using AssertJ that the mocked PaymentService has one processed order after placing the order.

This demonstrates how AssertJ can be used effectively alongside Mockito to write clear and comprehensive unit tests.

2. Conclusion

Conquering unit tests no longer requires wrestling with complex assertions. AssertJ swoops in as your trusty sidekick, empowering you to write clear, concise, and downright readable unit tests. You’ve explored the power of built-in matchers, the flexibility of custom matchers, and seamless integration with popular frameworks like JUnit and Mockito.

So, the next time you step into the testing arena, remember AssertJ is by your side!

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.