MODWRKFLOW-54: Migrate to Spring Boot 3.5.

The `folio-spring` dependency is actually using Spring Boot 4.
Therefore, this only migrates enough to compile and run the unit tests.

Bring in new controller advice testing practices that avoids needing to run a full Spring Boot service.

The `count()` can no longer be used.
Create a new `countAll()` with a `@Query` and utilize that.

Author: kaladay

service/pom.xml

@@ -18,7 +18,7 @@
 
   <properties>
     <openapi.server.port>9000</openapi.server.port>
-    <folio-spring.version>8.3.0-SNAPSHOT</folio-spring.version>
+    <folio-spring.version>10.0.0</folio-spring.version>
   </properties>
 
   <dependencies>

service/src/main/java/org/folio/rest/workflow/config/OkHttpConfig.java

@@ -1,22 +1,8 @@
 package org.folio.rest.workflow.config;
 
-import feign.okhttp.OkHttpClient;
-import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 @Configuration
 public class OkHttpConfig {
 
-  /**
-   * Add feignOkHttpClient to prevent issues introduced when using folio-spring-base.
-   *
-   * The issue involves enrichUrlAndHeadersClient, FeignClientConfiguration, and okhttp3.OkHttpClient.
-   *
-   * This defines a bean of type 'okhttp3.OkHttpClient' to prevent the error.
-   */
-  @Bean
-  public OkHttpClient feignOkHttpClient() {
-    return new OkHttpClient();
-  }
-
 }

service/src/main/java/org/folio/rest/workflow/controller/advice/WorkflowControllerAdvice.java

@@ -48,7 +48,7 @@ public ResponseEntity<String> handleWorkflowNotFoundException(WorkflowNotFoundEx
 
   @ResponseStatus(HttpStatus.FORBIDDEN)
   @ExceptionHandler(WorkflowAlreadyActiveException.class)
-  public ResponseEntity<String> handleWorkflowAlreadyActivrException(WorkflowAlreadyActiveException exception) {
+  public ResponseEntity<String> handleWorkflowAlreadyActiveException(WorkflowAlreadyActiveException exception) {
     return buildError(exception, HttpStatus.FORBIDDEN);
   }
 
@@ -66,7 +66,7 @@ public ResponseEntity<String> handleWorkflowEngineServiceException(WorkflowEngin
 
   @ResponseStatus(HttpStatus.BAD_REQUEST)
   @ExceptionHandler(WorkflowImportException.class)
-  public ResponseEntity<String> handleWorkflowImportExceptionException(WorkflowImportException exception) {
+  public ResponseEntity<String> handleWorkflowImportException(WorkflowImportException exception) {
     return buildError(exception, HttpStatus.BAD_REQUEST);
   }
 

service/src/main/java/org/folio/rest/workflow/model/repo/WorkflowRepo.java

@@ -2,6 +2,7 @@
 
 import org.folio.rest.workflow.model.Workflow;
 import org.folio.spring.cql.JpaCqlRepository;
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.rest.core.annotation.RepositoryRestResource;
 import org.springframework.data.rest.core.annotation.RestResource;
 
@@ -19,4 +20,7 @@ public interface WorkflowRepo extends JpaCqlRepository<Workflow, String> {
   @Override
   @RestResource(exported = false)
   public void deleteById(String id);
+
+  @Query("SELECT COUNT(*) FROM Workflow")
+  public long countAll();
 }

service/src/main/java/org/folio/rest/workflow/service/WorkflowCqlService.java

@@ -19,25 +19,25 @@ public WorkflowCqlService(ObjectMapper mapper, WorkflowRepo repo) {
     this.repo = repo;
   }
 
-  @Override
-  protected String getTypeName() {
-    return Workflow.class.getSimpleName().toLowerCase() + "s";
-  }
-
   @Override
   public ObjectNode findByCql(String query, Long offset, Integer limit) {
     Page<Workflow> page = null;
     long total = 0;
 
     if (StringUtils.isBlank(query)) {
       page = repo.findAll(new OffsetRequest(offset, limit));
-      total = repo.count();
+      total = repo.countAll();
     } else {
       page = repo.findByCql(query, new OffsetRequest(offset, limit));
-      total = repo.count(query);
+      total = repo.countByCql(query);
     }
 
     return toJson(page.toList(), total);
   }
 
+  @Override
+  protected String getTypeName() {
+    return Workflow.class.getSimpleName().toLowerCase() + "s";
+  }
+
 }

service/src/test/java/org/folio/rest/workflow/config/JunitHelperWebMvcConfig.java

@@ -0,0 +1,24 @@
+package org.folio.rest.workflow.config;
+
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.TestConfiguration;
+import org.springframework.test.context.ActiveProfiles;
+
+/**
+ * Provide custom web MVC settings for use during unit tests.
+ */
+@TestConfiguration
+@ActiveProfiles("test")
+public class JunitHelperWebMvcConfig {
+
+  @Bean
+  ObjectMapper objectMapper() {
+    final ObjectMapper mapper = new ObjectMapper();
+
+    mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
+
+    return mapper;
+  }
+}

service/src/test/java/org/folio/rest/workflow/controller/advice/EventControllerAdviceTest.java

@@ -1,98 +1,82 @@
 package org.folio.rest.workflow.controller.advice;
 
-import static org.folio.spring.test.mock.MockMvcConstant.APP_JSON;
-import static org.folio.spring.test.mock.MockMvcConstant.JSON_OBJECT;
-import static org.folio.spring.test.mock.MockMvcConstant.OKAPI_HEAD;
 import static org.folio.spring.test.mock.MockMvcConstant.VALUE;
-import static org.folio.spring.test.mock.MockMvcRequest.appendBody;
-import static org.folio.spring.test.mock.MockMvcRequest.appendHeaders;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
-import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.log;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
 import java.nio.file.FileSystemException;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import java.util.stream.Stream;
-import org.folio.rest.workflow.controller.EventController;
 import org.folio.rest.workflow.exception.EventPublishException;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
 import org.springframework.test.context.ActiveProfiles;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.MvcResult;
-import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
 
-@SpringBootTest(webEnvironment = WebEnvironment.MOCK)
-@AutoConfigureMockMvc
 @ExtendWith(MockitoExtension.class)
 @ActiveProfiles("test")
 class EventControllerAdviceTest {
 
-  private static final String PATH = "/events";
+  private static final Exception RUNTIME_EXC = new RuntimeException("Runtime failure.");
 
-  private static final String PATH_HANDLE = PATH + "/handle";
+  private static final EventPublishException EP_EXC = new EventPublishException(VALUE, RUNTIME_EXC);
 
-  @Autowired
-  private EventControllerAdvice eventControllerAdvice;
+  private static final FileSystemException FS_EXC = new FileSystemException(VALUE);
 
-  @Autowired
-  @Mock
-  private EventController eventController;
-
-  private MockMvc mvc;
+  private EventControllerAdvice advice;
 
   @BeforeEach
   void beforeEach() {
-    mvc = MockMvcBuilders.standaloneSetup(eventController)
-      .setControllerAdvice(eventControllerAdvice)
-      .build();
+    advice = new EventControllerAdvice();
+  }
+
+  @Test
+  void handleEventPublishExceptionTest() {
+
+    final String simpleName = EventPublishException.class.getSimpleName();
+    final ResponseEntity<String> response = advice.handleEventPublishException(EP_EXC);
+
+    assertNotNull(response);
+    assertNotNull(response.getBody());
+
+    assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
+    assertEquals(MediaType.APPLICATION_JSON, response.getHeaders().getContentType());
+    assertTrue(matchBody(response, simpleName));
   }
 
-  @ParameterizedTest
-  @MethodSource("provideExceptionsToMatchForActivateWorkflow")
-  void exceptionsThrownForActivateWorkflowTest(Exception exception, String simpleName, int status) throws Exception {
-    given(eventController.postHandleEvents(any(), any())).willAnswer(invocation -> { throw exception; });
+  @Test
+  void handleFileSystemExceptionTest() {
 
-    MockHttpServletRequestBuilder request = appendHeaders(post(PATH_HANDLE), OKAPI_HEAD, APP_JSON, APP_JSON);
+    final String simpleName = FileSystemException.class.getSimpleName();
+    final ResponseEntity<String> response = advice.handleFileSystemException(FS_EXC);
 
-    MvcResult result = mvc.perform(appendBody(request, JSON_OBJECT))
-      .andDo(log()).andExpect(status().is(status)).andReturn();
+    assertNotNull(response);
+    assertNotNull(response.getBody());
 
-    Pattern pattern = Pattern.compile("\"type\":\"" + simpleName + "\"");
-    Matcher matcher = pattern.matcher(result.getResponse().getContentAsString());
-    assertTrue(matcher.find());
+    assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+    assertEquals(MediaType.APPLICATION_JSON, response.getHeaders().getContentType());
+    assertTrue(matchBody(response, simpleName));
   }
 
   /**
-   * Helper function for parameterized test providing the exceptions to be matched for activate workflow.
+   * Match the class simple name in the response.
    *
-   * @return
-   *   The arguments array stream with the stream columns as:
-   *     - Exception exception.
-   *     - String simpleName (exception name to match).
-   *     - int status (response HTTP status code for the exception).
+   * @param response The response to search.
+   * @param simpleName The class name to match.
+   *
+   * @return TRUE on match; FALSE otherwise.
    */
-  private static Stream<Arguments> provideExceptionsToMatchForActivateWorkflow() {
-    Exception runtime = new RuntimeException("Runtime failure.");
+  private boolean matchBody(ResponseEntity<String> response, String simpleName) {
+
+    final Pattern pattern = Pattern.compile("\"type\":\"" + simpleName + "\"");
+    final Matcher matcher = pattern.matcher(response.getBody());
 
-    return Stream.of(
-      Arguments.of(new EventPublishException(VALUE, runtime), EventPublishException.class.getSimpleName(), 500),
-      Arguments.of(new FileSystemException(VALUE), FileSystemException.class.getSimpleName(), 400)
-    );
+    return matcher.find();
   }
 
 }