Merge pull request #16 from dm-drogeriemarkt/spring-boot-3

Spring boot 3

.github/workflows/run-with-maven.yml

@@ -39,10 +39,10 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-maven-
 
-      - name: Set up JDK 8
+      - name: Set up JDK 17
         uses: actions/setup-java@v2
         with:
-          java-version: '8'
+          java-version: '17'
           distribution: 'adopt'
           cache: maven
 

pom.xml

@@ -38,16 +38,16 @@
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
-        <version>2.1.12.RELEASE</version>
+        <version>3.1.5</version>
         <relativePath/> <!-- lookup parent from repository -->
     </parent>
 
     <properties>
         <project.version>2.0.0-SNAPSHOT</project.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <java.version>1.8</java.version>
+        <java.version>17</java.version>
         <jacoco.version>0.8.3</jacoco.version>
-        <maven-release-plugin.version>2.5.3</maven-release-plugin.version>
+        <maven-release-plugin.version>3.0.1</maven-release-plugin.version>
     </properties>
 
     <dependencies>
@@ -149,7 +149,7 @@
                     <plugin>
                         <groupId>org.apache.maven.plugins</groupId>
                         <artifactId>maven-gpg-plugin</artifactId>
-                        <version>3.0.1</version>
+                        <version>3.1.0</version>
                         <executions>
                             <execution>
                                 <id>sign-artifacts</id>
@@ -173,7 +173,7 @@
                     <plugin>
                         <groupId>org.apache.maven.plugins</groupId>
                         <artifactId>maven-source-plugin</artifactId>
-                        <version>2.4</version>
+                        <version>3.3.0</version>
                         <executions>
                             <execution>
                                 <id>attach-sources</id>
@@ -186,7 +186,7 @@
                     <plugin>
                         <groupId>org.apache.maven.plugins</groupId>
                         <artifactId>maven-javadoc-plugin</artifactId>
-                        <version>2.10.3</version>
+                        <version>3.6.0</version>
                         <executions>
                             <execution>
                                 <id>attach-javadocs</id>
@@ -224,7 +224,7 @@
                 <plugin>
                     <groupId>org.codehaus.mojo</groupId>
                     <artifactId>versions-maven-plugin</artifactId>
-                    <version>2.15.0</version>
+                    <version>2.16.1</version>
                     <configuration>
                         <generateBackupPoms>false</generateBackupPoms>
                     </configuration>

src/main/java/de/dm/retrylib/ApplicationShutdownHandler.java

@@ -1,9 +1,10 @@
 package de.dm.retrylib;
 
+import jakarta.annotation.PreDestroy;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import javax.annotation.PreDestroy;
+
 import java.util.concurrent.LinkedBlockingQueue;
 
 class ApplicationShutdownHandler {

src/main/java/de/dm/retrylib/RetrylibAutoConfiguration.java

@@ -2,6 +2,7 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.micrometer.core.instrument.MeterRegistry;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
@@ -12,6 +13,7 @@
 import java.util.List;
 import java.util.concurrent.LinkedBlockingQueue;
 
+@AutoConfiguration
 @Configuration
 @EnableScheduling
 @EnableConfigurationProperties(RetrylibProperties.class)

src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

@@ -0,0 +1 @@
+de.dm.retrylib.RetrylibAutoConfiguration

src/test/java/de/dm/retrylib/ApplicationShutdownHandlerUnitTest.java

@@ -1,6 +1,7 @@
 package de.dm.retrylib;
 
-import org.junit.Test;
+
+import org.junit.jupiter.api.Test;
 
 import java.util.concurrent.LinkedBlockingQueue;
 

src/test/java/de/dm/retrylib/RetryAspectUnitTest.java

@@ -2,29 +2,27 @@
 
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.hamcrest.CoreMatchers;
-import org.junit.Before;
-import org.junit.Test;
+import org.hamcrest.MatcherAssert;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.*;
 
-public class RetryAspectUnitTest {
+class RetryAspectUnitTest {
 
     private RetryAspect retryAspect;
 
     private RetryService retryService = mock(RetryService.class);
     private RetryHandler retryHandler = mock(RetryHandler.class);
 
-    @Before
-    public void setUp() {
+    @BeforeEach
+    void setUp() {
         retryAspect = new RetryAspect(retryService);
     }
 
     @Test
-    public void runWithRetryProceedsJoinPoint() throws Throwable {
+    void runWithRetryProceedsJoinPoint() throws Throwable {
         ProceedingJoinPoint proceedingJoinPoint = mock(ProceedingJoinPoint.class);
 
         retryAspect.runWithRetry(proceedingJoinPoint);
@@ -33,8 +31,8 @@ public void runWithRetryProceedsJoinPoint() throws Throwable {
     }
 
 
-    @Test(expected = UnknownError.class)
-    public void runWithRetryRequeuesInvocationOnError() throws Throwable {
+    @Test
+    void runWithRetryRequeuesInvocationOnError() throws Throwable {
         ProceedingJoinPoint proceedingJoinPoint = mock(ProceedingJoinPoint.class);
         doThrow(new UnknownError("Testerror")).when(proceedingJoinPoint).proceed();
         String payload = "payload";
@@ -43,14 +41,14 @@ public void runWithRetryRequeuesInvocationOnError() throws Throwable {
         when(proceedingJoinPoint.getArgs()).thenReturn(invocationArguments);
         when(proceedingJoinPoint.getTarget()).thenReturn(retryHandler);
 
-        retryAspect.runWithRetry(proceedingJoinPoint);
+        Assertions.assertThrows(UnknownError.class, () -> retryAspect.runWithRetry(proceedingJoinPoint));
 
         verify(proceedingJoinPoint).proceed();
         verify(retryService).queueForRetry(retryHandler.getClass(), payload);
     }
 
     @Test
-    public void runWithRetryRequeuesInvocationOnThrowable() throws Throwable {
+    void runWithRetryRequeuesInvocationOnThrowable() throws Throwable {
         ProceedingJoinPoint proceedingJoinPoint = mock(ProceedingJoinPoint.class);
         doThrow(new Throwable("TestThrowable")).when(proceedingJoinPoint).proceed();
         String payload = "payload";
@@ -60,14 +58,14 @@ public void runWithRetryRequeuesInvocationOnThrowable() throws Throwable {
         when(proceedingJoinPoint.getTarget()).thenReturn(retryHandler);
 
         Object returnValue = retryAspect.runWithRetry(proceedingJoinPoint);
-        assertThat(returnValue, CoreMatchers.nullValue());
+        MatcherAssert.assertThat(returnValue, CoreMatchers.nullValue());
 
         verify(proceedingJoinPoint).proceed();
         verify(retryService).queueForRetry(retryHandler.getClass(), payload);
     }
 
     @Test
-    public void retryableMethodsPointcutExistsAndCanBeInvoked() {
+    void retryableMethodsPointcutExistsAndCanBeInvoked() {
         retryAspect.retryableMethods();
     }
 

src/test/java/de/dm/retrylib/RetryEntitySerializerUnitTest.java

@@ -3,21 +3,23 @@
 import com.fasterxml.jackson.databind.DeserializationContext;
 import com.fasterxml.jackson.databind.JsonMappingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-public class RetryEntitySerializerUnitTest {
+class RetryEntitySerializerUnitTest {
 
     private final ObjectMapper objectMapper = mock(ObjectMapper.class);
 
     private final RetryEntitySerializer retryEntitySerializer = new RetryEntitySerializer(objectMapper);
 
     @Test
-    public void serialize() throws Exception {
+    void serialize() throws Exception {
         String payload = "payload";
         RetryEntity retryEntity = new RetryEntity("key", ExternalServiceRetryHandler.class, payload);
         when(objectMapper.writeValueAsString(retryEntity)).thenReturn("{}");
@@ -27,13 +29,13 @@ public void serialize() throws Exception {
         assertThat(serializedEntityAsJson, is("{}"));
     }
 
-    @Test(expected = IllegalArgumentException.class)
-    public void serializeThrowsExceptionIfEntityCouldNotBeSerialized() throws Exception {
+    @Test
+    void serializeThrowsExceptionIfEntityCouldNotBeSerialized() throws Exception {
         String payload = "payload";
         RetryEntity retryEntity = new RetryEntity("key", ExternalServiceRetryHandler.class, payload);
-        when(objectMapper.writeValueAsString(retryEntity)).thenThrow(JsonMappingException.from(mock(DeserializationContext.class), "provoked exception"));
+        doThrow(JsonMappingException.from(mock(DeserializationContext.class), "provoked exception")).when(objectMapper).writeValueAsString(retryEntity);
 
-        retryEntitySerializer.serialize(retryEntity);
+        Assertions.assertThrows(IllegalArgumentException.class, () -> retryEntitySerializer.serialize(retryEntity));
     }
 
 }

src/test/java/de/dm/retrylib/RetryProcessorUnitTest.java

@@ -1,21 +1,23 @@
 package de.dm.retrylib;
 
-import org.junit.Before;
-import org.junit.Test;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
-import static org.mockito.Matchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
-public class RetryProcessorUnitTest {
+class RetryProcessorUnitTest {
 
     private RetryProcessor retryProcessor;
     private List<RetryHandler> retryHandlers;
@@ -28,29 +30,30 @@ public void handleWithRetry(String payload) {
     };
     private RetryEntitySerializer retryEntitySerializer = mock(RetryEntitySerializer.class);
 
-    @Before
-    public void setUp() {
+    @BeforeEach
+    void setUp() {
         validRetryHandler = spy(validRetryHandler);
 
         retryHandlers = new ArrayList<>();
         retryHandlers.add(validRetryHandler);
         retryProcessor = new RetryProcessor(retryService, retryHandlers, retryEntitySerializer);
     }
 
-    @Test(expected = IllegalArgumentException.class)
-    public void processNextRetryBatchThrowsExceptionWhenNoHandlerIsAvailable() {
+    @Test
+    void processNextRetryBatchThrowsExceptionWhenNoHandlerIsAvailable() {
         RetryEntity retryEntity = new RetryEntity("key", String.class, "payload");
         List<RetryEntity> retryEntities = Collections.singletonList(retryEntity);
 
         when(retryService.loadNextRetryEntities(anyInt())).thenReturn(retryEntities);
 
-        retryProcessor.processNextRetryBatch();
+        Assertions.assertThrows(IllegalArgumentException.class, () -> retryProcessor.processNextRetryBatch());
 
-        verifyZeroInteractions(retryService);
+        verify(retryService).loadNextRetryEntities(anyInt());
+        verifyNoMoreInteractions(retryService);
     }
 
     @Test
-    public void processNextRetryBatchTriggersRetry() {
+    void processNextRetryBatchTriggersRetry() {
         RetryEntity retryEntity1 = new RetryEntity("key1", validRetryHandler.getClass(), "payload1");
         RetryEntity retryEntity2 = new RetryEntity("key2", validRetryHandler.getClass(), "payload2");
         List<RetryEntity> retryEntities = Arrays.asList(retryEntity1, retryEntity2);

src/test/java/de/dm/retrylib/RetryServiceUnitTest.java

@@ -1,18 +1,20 @@
 package de.dm.retrylib;
 
-import org.junit.Before;
-import org.junit.Test;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.concurrent.LinkedBlockingQueue;
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.mockito.Mockito.mock;
 
-public class RetryServiceUnitTest {
+class RetryServiceUnitTest {
 
     private RetryService retryService;
 
@@ -25,24 +27,25 @@ public void handleWithRetry(String payload) {
     };
     private LinkedBlockingQueue<RetryEntity> retryEntities;
 
-    @Before
-    public void setUp() {
+    @BeforeEach
+    void setUp() {
         retryEntities = new LinkedBlockingQueue<>(5);
         retryService = new RetryService(retryEntities, retryEntitySerializer);
     }
 
-    @Test(expected = IllegalStateException.class)
-    public void queueForRetryThrowsIllegalStateExceptionOnLimitReached() {
+    @Test
+    void queueForRetryThrowsIllegalStateExceptionOnLimitReached() {
         LinkedBlockingQueue<RetryEntity> retryEntities = new LinkedBlockingQueue<>(1);
         retryService = new RetryService(retryEntities, retryEntitySerializer);
 
         retryService.queueForRetry(demoRetryHandler.getClass(), "payload1");
-        retryService.queueForRetry(demoRetryHandler.getClass(), "payload2");
+
+        Assertions.assertThrows(IllegalStateException.class, () -> retryService.queueForRetry(demoRetryHandler.getClass(), "payload2"));
     }
 
 
     @Test
-    public void queueForRetryWritesToQueueSuccessfully() throws InterruptedException {
+    void queueForRetryWritesToQueueSuccessfully() throws InterruptedException {
         String payload = "payload";
         retryService.queueForRetry(demoRetryHandler.getClass(), payload);
 
@@ -53,7 +56,7 @@ public void queueForRetryWritesToQueueSuccessfully() throws InterruptedException
     }
 
     @Test
-    public void loadNextRetryEntitiesReturnsListOfEntries() {
+    void loadNextRetryEntitiesReturnsListOfEntries() {
         String payload = "payload";
         retryService.queueForRetry(demoRetryHandler.getClass(), payload);
 
@@ -63,7 +66,7 @@ public void loadNextRetryEntitiesReturnsListOfEntries() {
     }
 
     @Test
-    public void loadNextRetryEntitiesReturnsListOfEntriesLimitedByBatchSize() {
+    void loadNextRetryEntitiesReturnsListOfEntriesLimitedByBatchSize() {
         retryService.queueForRetry(demoRetryHandler.getClass(), "payload1");
         retryService.queueForRetry(demoRetryHandler.getClass(), "payload2");
         retryService.queueForRetry(demoRetryHandler.getClass(), "payload3");