How to Test a Spring AOP Aspect

1. Overview

Aspect-oriented programming (AOP) improves program design by separating a cross-cutting concern into a base unit, called an aspect, from the main application logic. Spring AOP is a framework that helps us implement aspects with ease.

AOP aspects are no different from other software components. They require different tests to verify their correctness. In this tutorial, we’ll learn how to conduct unit and integration tests on Spring AOP aspects.

2. What Is AOP?

AOP is a programming paradigm that complements object-oriented programming (OOP) to modularize cross-cutting concerns, which are functions spanning the main application. A class is a base unit in OOP, while an aspect is the base unit in AOP. Logging and transaction management are typical examples of cross-cutting concerns.

An aspect is composed of two components. One is the advice that defines the logic of the cross-cutting concern, while the other is a pointcut that specifies when we should apply the logic during application execution.

The following table provides an overview of the common AOP terms:

3. Execution Time Logging

In this section, let’s create a sample aspect that logs the execution time around a join point.

3.1. Maven Dependency

There are different Java AOP frameworks, such as Spring AOP and AspectJ. In this tutorial, we’ll use Spring AOP and include the following dependency in our pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>3.2.5</version>
</dependency>

For the logging part, we’re choosing SLF4J as the API and SLF4J simple provider for the logging implementation. SLF4J is a facade that provides a unified API across different logging implementations.

As such, we include the SLF4J API and SLF4J simple provider dependencies in our pom.xml as well:

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.13</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>2.0.13</version>
</dependency>

3.2. Execution Time Aspect

Our ExecutionTimeAspect class is simple and only contains an advice logExecutionTime(). We annotate our class with @Aspect and @Component to declare it an aspect and enable Spring to manage it:

@Aspect
@Component
public class ExecutionTimeAspect {
    private Logger log = LoggerFactory.getLogger(ExecutionTimeAspect.class);
    @Around("execution(* com.baeldung.unittest.ArraySorting.sort(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long t = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        log.info("Execution time=" + (System.currentTimeMillis() - t) + "ms");
        return result;
    }
}

The @Around annotation indicates the advice logExecutionTime() runs around the target join point defined by the pointcut expression execution(…). In Spring AOP, a join point is always a method.

4. Unit Test on Aspect

From a unit test perspective, we’re testing solely the logic inside the aspect without any dependencies, including the Spring application context. In this example, we use Mockito to mock the joinPoint and the logger, and then inject the mocks into our testing aspect.

The unit test class is annotated with @ExtendsWith(MockitoExtension.class) to enable the Mockito functionalities for JUnit 5. It automatically initializes mocks and injects them into our testing unit that’s annotated with @InjectMocks:

@ExtendWith(MockitoExtension.class)
class ExecutionTimeAspectUnitTest {
    @Mock
    private ProceedingJoinPoint joinPoint;
    @Mock
    private Logger logger;
    @InjectMocks
    private ExecutionTimeAspect aspect;
    @Test
    void whenExecuteJoinPoint_thenLoggerInfoIsCalled() throws Throwable {
        when(joinPoint.proceed()).thenReturn(null);
        aspect.logExecutionTime(joinPoint);
        verify(joinPoint, times(1)).proceed();
        verify(logger, times(1)).info(anyString());
    }
}

In this test case, we expect the joinPoint.proceed() method to be invoked once in the aspect. Also, the logger info() method should be invoked once as well to log the execution time.

To verify the logging message more precisely, we could use the ArgumentCaptor class to capture the log message. This enables us to assert the message produced beginning with “Execution time=“:

ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
verify(logger, times(1)).info(argumentCaptor.capture());
assertThat(argumentCaptor.getValue()).startsWith("Execution time=");

5. Integration Test on Aspect

From a integration test perspective, we’ll need the class implementation ArraySorting to apply our advice to the target class via pointcut expression. The sort() method simply calls the static method Collections.sort() to sort a list:

@Component
public class ArraySorting {
    public <T extends Comparable<? super T>> void sort(List<T> list) {
        Collections.sort(list);
    }
}

A question may arise: why don’t we apply our advice to the Collections.sort() static method instead? It’s a limitation of Spring AOP that it doesn’t work on static methods. Spring AOP creates dynamic proxies to intercept method calls. This mechanism requires invoking the actual method on the target object, while a static method can be invoked without an object. If we need to intercept static methods, we must adopt another AOP framework, such as AspectJ, that supports compile-time weaving.

In the integration test, we need the Spring application context to create a proxy object to intercept the target method and apply the advice. We annotate the integration test class with @SpringBootTest to load the application context that enables AOP and dependency injection capabilities:

@SpringBootTest
class ExecutionTimeAspectIntegrationTest {
    @Autowired
    private ArraySorting arraySorting;
    private List<Integer> getRandomNumberList(int size) {
        List<Integer> numberList = new ArrayList<>();
        for (int n=0;n<size;n++) {
            numberList.add((int) Math.round(Math.random() * size));
        }
        return numberList;
    }
    @Test
    void whenSort_thenExecutionTimeIsPrinted() {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream originalSystemOut = System.out;
        System.setOut(new PrintStream(baos));
        arraySorting.sort(getRandomNumberList(10000));
        System.setOut(originalSystemOut);
        String logOutput = baos.toString();
        assertThat(logOutput).contains("Execution time=");
    }
}

The test method can be divided into three parts. Initially, it redirects the output stream to a dedicated buffer for the  assertion later. Subsequently, it calls the sort()  method that invokes the advice within the aspect. It’s important to inject the ArraySorting instance via @Autowired instead of instantiating an instance with new ArraySorting(). This ensures Spring AOP is activated on the target class. Finally, it asserts whether the log is present in the buffer.

6. Conclusion

In this article, we discussed the fundamental concepts of AOP and saw how to use a Spring AOP aspect on a target class. We also looked into testing aspects with unit tests and integration tests to verify the correctness of the aspects.

As always, the code examples are available over on GitHub.