Assert with Grace: Custom Soft Assertions using AssertJ for Cleaner Code

Introduction

If you don’t know what a soft assertion is, please read Soft Asserts – Why should you use them for Unit and Integration tests?

This article is a continuation of Assert with Grace: Custom Assertions for Cleaner Code which shows you how to create custom assertions using AssertJ. Here you will learn how to extend its approach to use the soft assertion approach on top of the custom assertion.

Custom Soft Assertions with AssertJ

You can have a hard assertion using the Assertions class from AssertJ or a custom one. To get all the benefits of the soft assertion we need to:

• have a custom assertion implemented
• create the custom soft assertion class and extend the AbstractSoftAssertions from AssertJ

The custom assertion

You learned how to create a custom assertion in the Assert with Grace: Custom Assertions for Cleaner Code article. It looks like this:

public class SimulationAssert extends AbstractAssert<SimulationAssert, Simulation> {
    protected SimulationAssert(Simulation actual) {
        super(actual, SimulationAssert.class);
    }
    public static SimulationAssert assertThat(Simulation actual) {
        return new SimulationAssert(actual);
    }
    public SimulationAssert hasValidInstallments() {
        isNotNull();
        if (actual.getInstallments() < 2 || actual.getInstallments() >= 48) {
            failWithMessage("Installments must be must be equal or greater than 2 and equal or less than 48");
        }
        return this;
    }
    public SimulationAssert hasValidAmount() {
        isNotNull();
        var minimum = new BigDecimal("1.000");
        var maximum = new BigDecimal("40.000");
        if (actual.getAmount().compareTo(minimum) < 0 || actual.getAmount().compareTo(maximum) > 0) {
            failWithMessage("Amount must be equal or greater than $ 1.000 or equal or less than than $ 40.000");
        }
        return this;
    }
}

The usage of the custom assertion shows more legibility in the test as well as sends the responsibility of testing the valid values to it:

class SimulationsCustomAssertionTest {
    @Test
    void simulationErrorAssertion() {
        var simulation = Simulation.builder().name("John").cpf("9582728395").email("john@gmail.com")
                .amount(new BigDecimal("1.500")).installments(5).insurance(false).build();
        SimulationAssert.assertThat(simulation).hasValidInstallments();
        SimulationAssert.assertThat(simulation).hasValidAmount();
    }
}

With the custom assertion on hand, it’s time to implement the custom soft assertion.

Create the custom soft assertion

There is an easy process to create the custom soft assertion where the precondition is to have a custom assertion implemented. Given the previous article, we have the SimulationAssert class as the custom assertion and will create the SimulationSoftAssert as a custom soft assertion. These are the steps:

1. Extend the AbstractSoftAssertions class
2. Create the assertThat() method with:
   • the method returns an object as the custom assertion class
   • a parameter to the subject of the assertion
   • the method returns the method proxy where the parameters are the custom assertion class and the subject of the assertion
3. Create the assertSoftly() method with:
   • a parameter as a Consumer to the custom soft assert class
   • Use the SoftAssertionsProvider.assertSoftly() method as the parameter is the custom soft assertion class and the method parameter

The steps look complex, but in practice, you will end up with this:

public class SimulationSoftAssert extends AbstractSoftAssertions {
    public SimulationAssert assertThat(Simulation actual) {
        return proxy(SimulationAssert.class, Simulation.class, actual);
    }
    public static void assertSoftly(Consumer<SimulationSoftAssert> softly) {
        SoftAssertionsProvider.assertSoftly(SimulationSoftAssert.class, softly);
    }
}

Using the Custom Soft Assertion

The AssertJ SoftAssertion class is responsible for the soft assertions. This is the example applicable to the Simulation context:

@Test
public void normalSoftAssertion() {
    SoftAssertions.assertSoftly(softly -> {
        var simulation = Simulation.builder().name("John").cpf("9582728395").email("john@gmail.com")
                .amount(new BigDecimal("500")).installments(1).insurance(false).build();
        softly.assertThat(simulation.getInstallments()).isEqualTo(1);
        softly.assertThat(simulation.getAmount()).isEqualTo(500);
    });
}

The “problem” using it is that we won’t be able to use the custom assertion we have created. In the example above you can see the assertions in the installments and amount using the isEqualTo() as the SoftAssertions class has no access to the custom assertion.

We have solved this problem by creating the custom soft assertions class. So, instead of using the SoftAssertions class we will use the custom one: SimulationSoftAssert.

@Test
void simulationValidationErrorSoftAssertion() {
    var simulation = Simulation.builder().name("John").cpf("9582728395").email("john@gmail.com")
            .amount(new BigDecimal("500")).installments(1).insurance(false).build();
    SimulationSoftAssert.assertSoftly(softly -> {
        softly.assertThat(simulation).hasValidInstallments();
        softly.assertThat(simulation).hasValidAmount();
    });
}

The SimulationSoftAssert.assertSoftly() is a provider for the soft assertion that will call all internal methods to be able to manage the errors and other activities during the assertions. The assertThat() in use, inside the assertSoftly() will be the custom one which will have access to the custom assertion by the proxy() between the soft assert and the subject of the assertion.

Using this approach we have the custom assertions available in the soft assertion by the implementation of a custom one.

The end

That’s all folks!

You can find a fully implemented and working example in the credit-api project, where you can see the following:

• SimulationAssert class
• Test usage in the SimulationsCustomAssertionTest class