Exception assertion of assertj

This page mainly talks about AssertJ Exception assertion for .

summary

In this quick navigation , We are mainly here to talk about AssertJ It's abnormal （exception） Assertion .

of AssertJ Project , Please visit  AssertJ / Fluent assertions for java  page .

Don't use AssertJ

If not used AssertJ, We need to catch an exception first , Then make assertions in the exception .

For example, the following pseudo code , We caught an exception , And then judge .

try {
    // ...
} catch (Exception e) {
    // assertions
}

however , If the program does not throw an exception during execution , In the above use case , The test will pass .

In order for assertions to be executed , Why do we need to manually trigger an exception ？

Use AssertJ

stay Java 8 Later versions , We can do that by using AssertJ and lambda expression , It's very easy to assert exceptions .

Use  assertThatThrownBy()  Method

Let's see what the following code will throw  IndexOutOfBoundsException  abnormal ：

This is because we define a List Is the length of the 2 , But we have a line of code that will access List Of the 3 Elements , The above code must throw an exception .

        assertThatThrownBy(() -> {
            ArrayList<String> myStringList = new ArrayList<String>(Arrays.asList("Strine one", "String two"));
            myStringList.get(2);
        }).isInstanceOf(IndexOutOfBoundsException.class)
                .hasMessageStartingWith("Index 2");

Note that the code snippet above may throw a lambda Expression exception .

Of course , We can also use AssertJ To provide a chained assertion , That's why we don't use Junit Reason for self assertion .

                .hasMessageStartingWith("Index 2")
                .hasMessageContaining("2")
                .hasMessageEndingWith("length 2")
                .hasMessageContaining("Index 2")
                .hasNoCause();

Use  assertThatExceptionOfType  Method

This method is similar to the method used above , Because we know that the execution of this program will throw an exception , So we specify exceptions at the very beginning of the program ：

        assertThatExceptionOfType(ArithmeticException.class).isThrownBy(() -> {
                    int numerator = 10;
                    int denominator = 0;
                    int quotient = numerator / denominator;
                })
                .withMessageContaining("/ by zero");

The above method , Because we used 0 Divisor , So an exception must be thrown .

We asserted this exception at the very beginning of the program .

Use  assertThatIOException  And other common types

AssertJ in the light of Some common exceptions are wrapped , You can use these wrapped exceptions directly ：

assertThatIOException().isThrownBy(() -> {
    // ...
});

And other similar exceptions ：

• assertThatIllegalArgumentException()
• assertThatIllegalStateException()
• assertThatIOException()
• assertThatNullPointerException()

Detach exceptions from assertions

Optional , We can separate exceptions from assertions .

The way to separate is to add one  when  and  then  Logical segment ：

        // when
        Throwable thrown = catchThrowable(() -> {
            int numerator = 10;
            int denominator = 0;
            int quotient = numerator / denominator;
        });

        // then
        assertThat(thrown).isInstanceOf(ArithmeticException.class)
                .hasMessageContaining("/ by zero");
    }

The above code first throws an exception , Then, assert and judge the thrown exception .

Conclusion

In this essay , We are right. AssertJ How to make exception assertions is briefly introduced , It also discusses AssertJ How to make exception assertions .

AssertJ It's abnormal （Exception ） Assertion - Java - OSSEZhttps://www.ossez.com/t/assertj-exception/13988