Port converter, security, MCP and CDI-infra tests off Spring to Quarkus

app/common/src/test/java/stirling/software/common/util/AppArgsCaptureTest.java

@@ -1,16 +1,20 @@
 package stirling.software.common.util;
 
-import static org.junit.jupiter.api.Assertions.*;
-import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.List;
 
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
-import org.springframework.boot.ApplicationArguments;
 
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
+/**
+ * MIGRATION (Spring -> Quarkus): {@code AppArgsCapture} replaced the Spring {@code
+ * ApplicationRunner.run(ApplicationArguments)} hook with a CDI {@code @Observes StartupEvent}
+ * observer reading a {@code @CommandLineArguments String[]} field. The tests drive that observer
+ * directly: the {@code args} field and {@code onStart} method are package-private, so they are set
+ * and invoked without a running CDI container (the {@code StartupEvent} payload is unused).
+ */
 class AppArgsCaptureTest {
 
     private AppArgsCapture capture;
@@ -22,31 +26,27 @@ class AppArgsCaptureTest {
     }
 
     @Test
-    void run_withArgs_capturesArgs() {
-        ApplicationArguments args = mock(ApplicationArguments.class);
-        when(args.getSourceArgs()).thenReturn(new String[] {"--server.port=8080", "--debug"});
-        capture.run(args);
+    void onStart_withArgs_capturesArgs() {
+        capture.args = new String[] {"--server.port=8080", "--debug"};
+        capture.onStart(null);
         assertEquals(List.of("--server.port=8080", "--debug"), AppArgsCapture.APP_ARGS.get());
     }
 
     @Test
-    void run_withNoArgs_capturesEmptyList() {
-        ApplicationArguments args = mock(ApplicationArguments.class);
-        when(args.getSourceArgs()).thenReturn(new String[] {});
-        capture.run(args);
+    void onStart_withNoArgs_capturesEmptyList() {
+        capture.args = new String[] {};
+        capture.onStart(null);
         assertEquals(List.of(), AppArgsCapture.APP_ARGS.get());
     }
 
     @Test
-    void run_calledTwice_overwritesPreviousArgs() {
-        ApplicationArguments args1 = mock(ApplicationArguments.class);
-        when(args1.getSourceArgs()).thenReturn(new String[] {"--first"});
-        capture.run(args1);
+    void onStart_calledTwice_overwritesPreviousArgs() {
+        capture.args = new String[] {"--first"};
+        capture.onStart(null);
         assertEquals(List.of("--first"), AppArgsCapture.APP_ARGS.get());
 
-        ApplicationArguments args2 = mock(ApplicationArguments.class);
-        when(args2.getSourceArgs()).thenReturn(new String[] {"--second", "--third"});
-        capture.run(args2);
+        capture.args = new String[] {"--second", "--third"};
+        capture.onStart(null);
         assertEquals(List.of("--second", "--third"), AppArgsCapture.APP_ARGS.get());
     }
 

app/common/src/test/java/stirling/software/common/util/ApplicationContextProviderTest.java

@@ -1,110 +1,142 @@
 package stirling.software.common.util;
 
-import static org.junit.jupiter.api.Assertions.*;
-import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
 
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.NoSuchBeanDefinitionException;
-import org.springframework.context.ApplicationContext;
+import org.mockito.MockedStatic;
 
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
+import io.quarkus.arc.Arc;
+import io.quarkus.arc.ArcContainer;
+import io.quarkus.arc.InjectableInstance;
+
+import jakarta.enterprise.inject.literal.NamedLiteral;
+
+/**
+ * MIGRATION (Spring -> Quarkus): {@code ApplicationContextProvider} now resolves beans through
+ * the Arc CDI container ({@code Arc.container().select(...)}) instead of a Spring {@code
+ * ApplicationContext}. Tests drive it by mocking the static {@code Arc.container()} entry point;
+ * the "no container" state (a non-{@code @QuarkusTest} unit test) is simulated by stubbing {@code
+ * Arc.container()} to {@code null}, and "bean not found" by an unresolvable {@link
+ * InjectableInstance}. The Spring-only {@code setApplicationContext(...)} mutator was removed, so
+ * the former context-swap test no longer applies.
+ *
+ * <p>Every collaborator mock is fully built into a local before it is handed to {@code thenReturn},
+ * so a helper's own stubbing never nests inside an in-progress {@code when(...)} (which would trip
+ * {@code UnfinishedStubbingException}).
+ */
 class ApplicationContextProviderTest {
 
-    private ApplicationContextProvider provider;
-
-    @BeforeEach
-    void setUp() {
-        provider = new ApplicationContextProvider();
-        // Reset to null state
-        provider.setApplicationContext(null);
+    @SuppressWarnings("unchecked")
+    private static <T> InjectableInstance<T> resolvable(T bean) {
+        InjectableInstance<T> instance = mock(InjectableInstance.class);
+        when(instance.isResolvable()).thenReturn(true);
+        when(instance.get()).thenReturn(bean);
+        return instance;
     }
 
-    @AfterEach
-    void tearDown() {
-        // Clean up static state
-        provider.setApplicationContext(null);
+    @SuppressWarnings("unchecked")
+    private static <T> InjectableInstance<T> unresolvable() {
+        InjectableInstance<T> instance = mock(InjectableInstance.class);
+        when(instance.isResolvable()).thenReturn(false);
+        return instance;
+    }
+
+    private static <T> ArcContainer containerSelecting(
+            Class<T> type, InjectableInstance<T> instance) {
+        ArcContainer container = mock(ArcContainer.class);
+        when(container.select(type)).thenReturn(instance);
+        return container;
+    }
+
+    private static <T> ArcContainer containerSelectingNamed(
+            Class<T> type, String name, InjectableInstance<T> instance) {
+        ArcContainer container = mock(ArcContainer.class);
+        when(container.select(type, NamedLiteral.of(name))).thenReturn(instance);
+        return container;
     }
 
     @Test
-    void getBean_byClass_whenNoContext_returnsNull() {
-        provider.setApplicationContext(null);
-        assertNull(ApplicationContextProvider.getBean(String.class));
+    void getBean_byClass_whenNoContainer_returnsNull() {
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(null);
+            assertNull(ApplicationContextProvider.getBean(String.class));
+        }
     }
 
     @Test
     void getBean_byClass_whenBeanExists_returnsBean() {
-        ApplicationContext ctx = mock(ApplicationContext.class);
-        when(ctx.getBean(String.class)).thenReturn("hello");
-        provider.setApplicationContext(ctx);
-        assertEquals("hello", ApplicationContextProvider.getBean(String.class));
+        ArcContainer container = containerSelecting(String.class, resolvable("hello"));
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(container);
+            assertEquals("hello", ApplicationContextProvider.getBean(String.class));
+        }
     }
 
     @Test
     void getBean_byClass_whenBeanNotFound_returnsNull() {
-        ApplicationContext ctx = mock(ApplicationContext.class);
-        when(ctx.getBean(String.class)).thenThrow(new NoSuchBeanDefinitionException(""));
-        provider.setApplicationContext(ctx);
-        assertNull(ApplicationContextProvider.getBean(String.class));
+        ArcContainer container = containerSelecting(String.class, unresolvable());
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(container);
+            assertNull(ApplicationContextProvider.getBean(String.class));
+        }
     }
 
     @Test
-    void getBean_byNameAndClass_whenNoContext_returnsNull() {
-        provider.setApplicationContext(null);
-        assertNull(ApplicationContextProvider.getBean("myBean", String.class));
+    void getBean_byNameAndClass_whenNoContainer_returnsNull() {
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(null);
+            assertNull(ApplicationContextProvider.getBean("myBean", String.class));
+        }
     }
 
     @Test
     void getBean_byNameAndClass_whenBeanExists_returnsBean() {
-        ApplicationContext ctx = mock(ApplicationContext.class);
-        when(ctx.getBean("myBean", String.class)).thenReturn("world");
-        provider.setApplicationContext(ctx);
-        assertEquals("world", ApplicationContextProvider.getBean("myBean", String.class));
+        ArcContainer container =
+                containerSelectingNamed(String.class, "myBean", resolvable("world"));
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(container);
+            assertEquals("world", ApplicationContextProvider.getBean("myBean", String.class));
+        }
     }
 
     @Test
     void getBean_byNameAndClass_whenBeanNotFound_returnsNull() {
-        ApplicationContext ctx = mock(ApplicationContext.class);
-        when(ctx.getBean("missing", String.class)).thenThrow(new NoSuchBeanDefinitionException(""));
-        provider.setApplicationContext(ctx);
-        assertNull(ApplicationContextProvider.getBean("missing", String.class));
+        ArcContainer container = containerSelectingNamed(String.class, "missing", unresolvable());
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(container);
+            assertNull(ApplicationContextProvider.getBean("missing", String.class));
+        }
     }
 
     @Test
-    void containsBean_whenNoContext_returnsFalse() {
-        provider.setApplicationContext(null);
-        assertFalse(ApplicationContextProvider.containsBean(String.class));
+    void containsBean_whenNoContainer_returnsFalse() {
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(null);
+            assertFalse(ApplicationContextProvider.containsBean(String.class));
+        }
     }
 
     @Test
     void containsBean_whenBeanExists_returnsTrue() {
-        ApplicationContext ctx = mock(ApplicationContext.class);
-        when(ctx.getBean(String.class)).thenReturn("exists");
-        provider.setApplicationContext(ctx);
-        assertTrue(ApplicationContextProvider.containsBean(String.class));
+        ArcContainer container = containerSelecting(String.class, resolvable("exists"));
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(container);
+            assertTrue(ApplicationContextProvider.containsBean(String.class));
+        }
     }
 
     @Test
     void containsBean_whenBeanNotFound_returnsFalse() {
-        ApplicationContext ctx = mock(ApplicationContext.class);
-        when(ctx.getBean(Integer.class)).thenThrow(new NoSuchBeanDefinitionException(""));
-        provider.setApplicationContext(ctx);
-        assertFalse(ApplicationContextProvider.containsBean(Integer.class));
-    }
-
-    @Test
-    void setApplicationContext_updatesStaticContext() {
-        ApplicationContext ctx = mock(ApplicationContext.class);
-        when(ctx.getBean(String.class)).thenReturn("test");
-        provider.setApplicationContext(ctx);
-        assertEquals("test", ApplicationContextProvider.getBean(String.class));
-
-        // Now set a different context
-        ApplicationContext ctx2 = mock(ApplicationContext.class);
-        when(ctx2.getBean(String.class)).thenReturn("updated");
-        provider.setApplicationContext(ctx2);
-        assertEquals("updated", ApplicationContextProvider.getBean(String.class));
+        ArcContainer container = containerSelecting(Integer.class, unresolvable());
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(container);
+            assertFalse(ApplicationContextProvider.containsBean(Integer.class));
+        }
     }
 }

app/common/src/test/java/stirling/software/common/util/SpringContextHolderTest.java

@@ -1,79 +1,108 @@
 package stirling.software.common.util;
 
-import static org.junit.jupiter.api.Assertions.*;
-import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
 
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
-import org.springframework.context.ApplicationContext;
+import org.mockito.MockedStatic;
 
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
+import io.quarkus.arc.Arc;
+import io.quarkus.arc.ArcContainer;
+import io.quarkus.arc.InjectableInstance;
+
+/**
+ * MIGRATION (Spring -> Quarkus): {@code SpringContextHolder} now resolves beans through the Arc
+ * CDI container ({@code Arc.container().select(...)} / {@code isRunning()}) instead of a Spring
+ * {@code ApplicationContext}. Tests drive it by mocking the static {@code Arc.container()} entry
+ * point. The Spring-only {@code setApplicationContext(...)} mutator was removed, so "container not
+ * initialized" is now expressed as {@code Arc.container() == null} (or a non-running container),
+ * and "bean not found" as an unresolvable {@link InjectableInstance}.
+ *
+ * <p>Every collaborator mock is fully built into a local before it is handed to {@code thenReturn},
+ * so a helper's own stubbing never nests inside an in-progress {@code when(...)} (which would trip
+ * {@code UnfinishedStubbingException}).
+ */
 class SpringContextHolderTest {
 
-    private ApplicationContext mockApplicationContext;
-    private SpringContextHolder contextHolder;
+    @SuppressWarnings("unchecked")
+    private static <T> InjectableInstance<T> resolvable(T bean) {
+        InjectableInstance<T> instance = mock(InjectableInstance.class);
+        when(instance.isResolvable()).thenReturn(true);
+        when(instance.get()).thenReturn(bean);
+        return instance;
+    }
 
-    @BeforeEach
-    void setUp() {
-        mockApplicationContext = mock(ApplicationContext.class);
-        contextHolder = new SpringContextHolder();
+    @SuppressWarnings("unchecked")
+    private static <T> InjectableInstance<T> unresolvable() {
+        InjectableInstance<T> instance = mock(InjectableInstance.class);
+        when(instance.isResolvable()).thenReturn(false);
+        return instance;
+    }
+
+    private static ArcContainer runningContainer() {
+        ArcContainer container = mock(ArcContainer.class);
+        when(container.isRunning()).thenReturn(true);
+        return container;
+    }
+
+    private static <T> ArcContainer runningContainerSelecting(
+            Class<T> type, InjectableInstance<T> instance) {
+        ArcContainer container = mock(ArcContainer.class);
+        when(container.isRunning()).thenReturn(true);
+        when(container.select(type)).thenReturn(instance);
+        return container;
     }
 
     @Test
-    void testSetApplicationContext() {
-        // Act
-        contextHolder.setApplicationContext(mockApplicationContext);
-
-        // Assert
-        assertTrue(SpringContextHolder.isInitialized());
+    void isInitialized_whenContainerRunning_returnsTrue() {
+        ArcContainer container = runningContainer();
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(container);
+            assertTrue(SpringContextHolder.isInitialized());
+        }
     }
 
     @Test
-    void testGetBean_ByType() {
-        // Arrange
-        contextHolder.setApplicationContext(mockApplicationContext);
+    void isInitialized_whenNoContainer_returnsFalse() {
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(null);
+            assertFalse(SpringContextHolder.isInitialized());
+        }
+    }
+
+    @Test
+    void getBean_byType_whenBeanExists_returnsBean() {
         TestBean expectedBean = new TestBean();
-        when(mockApplicationContext.getBean(TestBean.class)).thenReturn(expectedBean);
-
-        // Act
-        TestBean result = SpringContextHolder.getBean(TestBean.class);
-
-        // Assert
-        assertSame(expectedBean, result);
-        verify(mockApplicationContext).getBean(TestBean.class);
+        ArcContainer container =
+                runningContainerSelecting(TestBean.class, resolvable(expectedBean));
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(container);
+            assertSame(expectedBean, SpringContextHolder.getBean(TestBean.class));
+        }
     }
 
     @Test
-    void testGetBean_ApplicationContextNotSet() {
-        // Don't set application context
-
-        // Act
-        TestBean result = SpringContextHolder.getBean(TestBean.class);
-
-        // Assert
-        assertNull(result);
+    void getBean_byType_whenContainerNotInitialized_returnsNull() {
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(null);
+            assertNull(SpringContextHolder.getBean(TestBean.class));
+        }
     }
 
     @Test
-    void testGetBean_BeanNotFound() {
-        // Arrange
-        contextHolder.setApplicationContext(mockApplicationContext);
-        when(mockApplicationContext.getBean(TestBean.class)).thenThrow(new MyBeansException());
-
-        // Act
-        TestBean result = SpringContextHolder.getBean(TestBean.class);
-
-        // Assert
-        assertNull(result);
+    void getBean_byType_whenBeanNotResolvable_returnsNull() {
+        ArcContainer container = runningContainerSelecting(TestBean.class, unresolvable());
+        try (MockedStatic<Arc> arc = mockStatic(Arc.class)) {
+            arc.when(Arc::container).thenReturn(container);
+            assertNull(SpringContextHolder.getBean(TestBean.class));
+        }
     }
 
     // Simple test class
     private static class TestBean {}
-
-    private static class MyBeansException extends org.springframework.beans.BeansException {
-        public MyBeansException() {
-            super("Bean not found");
-        }
-    }
 }

app/core/src/test/java/stirling/software/SPDF/config/AutoJobPostMappingWeightTest.java

@@ -2,48 +2,91 @@ package stirling.software.SPDF.config;
 
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.io.File;
 import java.io.IOException;
-import java.lang.reflect.Method;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
 
+import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.AnnotationTarget;
+import org.jboss.jandex.AnnotationValue;
+import org.jboss.jandex.DotName;
+import org.jboss.jandex.Index;
+import org.jboss.jandex.Indexer;
+import org.jboss.jandex.MethodInfo;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
-import org.springframework.core.io.Resource;
-import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
-import org.springframework.core.io.support.ResourcePatternResolver;
-import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
-import org.springframework.core.type.classreading.MetadataReader;
-import org.springframework.core.type.classreading.MetadataReaderFactory;
-import org.springframework.core.type.filter.TypeFilter;
-
-import stirling.software.common.annotations.AutoJobPostMapping;
 
 /**
- * Build-time guardrail: every {@link AutoJobPostMapping} method must declare an explicit {@code
+ * Build-time guardrail: every {@code @AutoJobPostMapping} method must declare an explicit {@code
  * resourceWeight}.
  *
  * <p>The credits interceptor multiplies {@code resourceWeight} into the per-call charge. An
  * endpoint that falls through to the annotation default produces a charge derived from a value
- * nobody chose — silently under- or over-billing depending on the endpoint's true cost. Forcing
+ * nobody chose - silently under- or over-billing depending on the endpoint's true cost. Forcing
  * each method to pick a value from {@link stirling.software.common.enumeration.ResourceWeight}
  * keeps the choice deliberate.
  *
  * <p>The annotation's default is {@link Integer#MIN_VALUE} (a sentinel). Runtime readers clamp the
- * value into {@code [1, 100]}, so a missed declaration can't crash production — this test is the
+ * value into {@code [1, 100]}, so a missed declaration can't crash production - this test is the
  * contract, the clamp is the safety net.
  *
  * <p>Lives in {@code :stirling-pdf} (core) because that's the module whose compile classpath
  * transitively sees every other module's controllers ({@code :common}, {@code :proprietary}, and
  * {@code :saas} when enabled).
+ *
+ * <p>MIGRATION (Spring -&gt; Quarkus): the previous Spring {@code MetadataReader} class-file scan
+ * was replaced with Jandex (the indexer Quarkus itself uses). Both read annotation metadata
+ * straight from bytecode, so no class on the test classpath has to be loaded just to find the few
+ * that are annotated.
  */
 class AutoJobPostMappingWeightTest {
 
-    private static final String SCAN_BASE_PACKAGE = "stirling.software";
+    private static final String SCAN_PREFIX = "stirling/software/";
+    private static final DotName AUTO_JOB_POST_MAPPING =
+            DotName.createSimple("stirling.software.common.annotations.AutoJobPostMapping");
+
+    /** {@code AutoJobPostMapping#resourceWeight()} default - "no explicit value chosen". */
+    private static final int UNSET_WEIGHT = Integer.MIN_VALUE;
+
+    private static Index index;
+
+    @BeforeAll
+    static void buildIndex() throws IOException {
+        Indexer indexer = new Indexer();
+        for (String entry : System.getProperty("java.class.path").split(File.pathSeparator)) {
+            File root = new File(entry);
+            if (!root.exists()) {
+                continue;
+            }
+            if (root.isDirectory()) {
+                indexClassDirectory(indexer, root.toPath());
+            } else if (entry.endsWith(".jar")) {
+                indexJar(indexer, root);
+            }
+        }
+        index = indexer.complete();
+    }
 
     @Test
-    void everyAutoJobPostMappingDeclaresExplicitResourceWeight() throws Exception {
-        List<String> offenders = findOffendingMethods();
+    void everyAutoJobPostMappingDeclaresExplicitResourceWeight() {
+        List<String> offenders = new ArrayList<>();
+        for (AnnotationInstance annotation : index.getAnnotations(AUTO_JOB_POST_MAPPING)) {
+            if (annotation.target().kind() != AnnotationTarget.Kind.METHOD) {
+                continue;
+            }
+            AnnotationValue weight = annotation.value("resourceWeight");
+            if (weight == null || weight.asInt() == UNSET_WEIGHT) {
+                MethodInfo method = annotation.target().asMethod();
+                offenders.add(method.declaringClass().name() + "#" + method.name());
+            }
+        }
 
         assertTrue(
                 offenders.isEmpty(),
@@ -55,65 +98,15 @@ class AutoJobPostMappingWeightTest {
                                 + String.join("\n  - ", offenders));
     }
 
-    private List<String> findOffendingMethods() throws IOException, ClassNotFoundException {
-        List<String> offenders = new ArrayList<>();
-        for (Class<?> candidate : scanForCandidateClasses()) {
-            for (Method method : candidate.getDeclaredMethods()) {
-                AutoJobPostMapping annotation = method.getAnnotation(AutoJobPostMapping.class);
-                if (annotation == null) {
-                    continue;
-                }
-                if (annotation.resourceWeight() == Integer.MIN_VALUE) {
-                    offenders.add(candidate.getName() + "#" + method.getName());
-                }
-            }
-        }
-        return offenders;
-    }
-
-    /**
-     * Returns every class under {@link #SCAN_BASE_PACKAGE} that has an @AutoJobPostMapping method.
-     */
-    private List<Class<?>> scanForCandidateClasses() throws IOException, ClassNotFoundException {
-        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
-        MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resolver);
-
-        String pattern = "classpath*:" + SCAN_BASE_PACKAGE.replace('.', '/') + "/**/*.class";
-        Resource[] resources = resolver.getResources(pattern);
-
-        // Pre-filter by reading annotation metadata from the class file so we don't have to load
-        // every class on the test classpath just to find the few that are annotated.
-        TypeFilter mentionsAutoJobPostMapping =
-                (reader, factory) ->
-                        reader.getAnnotationMetadata()
-                                        .getAnnotatedMethods(AutoJobPostMapping.class.getName())
-                                        .size()
-                                > 0;
-
-        List<Class<?>> matches = new ArrayList<>();
-        for (Resource resource : resources) {
-            if (!resource.isReadable()) {
-                continue;
-            }
-            MetadataReader reader = metadataReaderFactory.getMetadataReader(resource);
-            if (!mentionsAutoJobPostMapping.match(reader, metadataReaderFactory)) {
-                continue;
-            }
-            matches.add(Class.forName(reader.getClassMetadata().getClassName()));
-        }
-        return matches;
-    }
-
     /**
      * Sanity check that the classpath scan returns non-empty; otherwise the main test passes
      * vacuously.
      */
     @Test
-    void scannerFindsAtLeastOneAutoJobPostMapping() throws Exception {
+    void scannerFindsAtLeastOneAutoJobPostMapping() {
         long count =
-                scanForCandidateClasses().stream()
-                        .flatMap(c -> java.util.Arrays.stream(c.getDeclaredMethods()))
-                        .filter(m -> m.isAnnotationPresent(AutoJobPostMapping.class))
+                index.getAnnotations(AUTO_JOB_POST_MAPPING).stream()
+                        .filter(a -> a.target().kind() == AnnotationTarget.Kind.METHOD)
                         .count();
 
         assertTrue(
@@ -125,8 +118,38 @@ class AutoJobPostMappingWeightTest {
                                 + ". Scanner regression?");
     }
 
-    @SuppressWarnings("unused")
-    private static String describeCandidates(List<Class<?>> candidates) {
-        return candidates.stream().map(Class::getName).collect(Collectors.joining(", "));
+    private static void indexClassDirectory(Indexer indexer, Path root) throws IOException {
+        Path base = root.resolve(SCAN_PREFIX);
+        if (!Files.isDirectory(base)) {
+            return;
+        }
+        try (Stream<Path> classes = Files.walk(base)) {
+            List<Path> classFiles =
+                    classes.filter(p -> p.toString().endsWith(".class"))
+                            .filter(p -> !p.getFileName().toString().equals("module-info.class"))
+                            .toList();
+            for (Path classFile : classFiles) {
+                try (InputStream in = Files.newInputStream(classFile)) {
+                    indexer.index(in);
+                }
+            }
+        }
+    }
+
+    private static void indexJar(Indexer indexer, File jar) throws IOException {
+        try (ZipFile zip = new ZipFile(jar)) {
+            var entries = zip.entries();
+            while (entries.hasMoreElements()) {
+                ZipEntry zipEntry = entries.nextElement();
+                String name = zipEntry.getName();
+                if (name.startsWith(SCAN_PREFIX)
+                        && name.endsWith(".class")
+                        && !name.endsWith("module-info.class")) {
+                    try (InputStream in = zip.getInputStream(zipEntry)) {
+                        indexer.index(in);
+                    }
+                }
+            }
+        }
     }
 }

app/core/src/test/java/stirling/software/SPDF/controller/api/AdditionalLanguageJsControllerTest.java

@@ -1,59 +1,48 @@
 package stirling.software.SPDF.controller.api;
 
-import static org.hamcrest.Matchers.containsString;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.*;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
 
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 
 import org.junit.jupiter.api.Test;
-import org.springframework.http.MediaType;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
 
 import stirling.software.SPDF.service.LanguageService;
 
+/**
+ * MIGRATION (Spring -> Quarkus): the controller is a JAX-RS resource whose handler returns the
+ * generated JavaScript as a plain {@code String} (the {@code application/javascript} content type
+ * is declared via {@code @Produces} and is not observable from a direct method call). The former
+ * MockMvc body-substring assertions are preserved as {@code String#contains} checks on the returned
+ * value.
+ */
 class AdditionalLanguageJsControllerTest {
 
     @Test
-    void returnsJsWithSupportedLanguagesAndFunction() throws Exception {
+    void returnsJsWithSupportedLanguagesAndFunction() {
         LanguageService lang = mock(LanguageService.class);
         // LinkedHashSet for deterministic order in the array
         when(lang.getSupportedLanguages())
                 .thenReturn(new LinkedHashSet<>(List.of("de_DE", "en_US")));
 
-        MockMvc mvc =
-                MockMvcBuilders.standaloneSetup(new AdditionalLanguageJsController(lang)).build();
+        String js = new AdditionalLanguageJsController(lang).generateAdditionalLanguageJs();
 
-        mvc.perform(get("/js/additionalLanguageCode.js"))
-                .andExpect(status().isOk())
-                .andExpect(content().contentType(new MediaType("application", "javascript")))
-                .andExpect(
-                        content()
-                                .string(
-                                        containsString(
-                                                "const supportedLanguages ="
-                                                        + " [\"de_DE\",\"en_US\"];")))
-                .andExpect(content().string(containsString("function getDetailedLanguageCode()")))
-                .andExpect(content().string(containsString("return \"en_US\";")));
+        assertTrue(js.contains("const supportedLanguages = [\"de_DE\",\"en_US\"];"));
+        assertTrue(js.contains("function getDetailedLanguageCode()"));
+        assertTrue(js.contains("return \"en_US\";"));
 
         verify(lang, times(1)).getSupportedLanguages();
     }
 
     @Test
-    void emptySupportedLanguagesYieldsEmptyArray() throws Exception {
+    void emptySupportedLanguagesYieldsEmptyArray() {
         LanguageService lang = mock(LanguageService.class);
         when(lang.getSupportedLanguages()).thenReturn(Set.of());
 
-        MockMvc mvc =
-                MockMvcBuilders.standaloneSetup(new AdditionalLanguageJsController(lang)).build();
+        String js = new AdditionalLanguageJsController(lang).generateAdditionalLanguageJs();
 
-        mvc.perform(get("/js/additionalLanguageCode.js"))
-                .andExpect(status().isOk())
-                .andExpect(content().contentType(new MediaType("application", "javascript")))
-                .andExpect(content().string(containsString("const supportedLanguages = [];")));
+        assertTrue(js.contains("const supportedLanguages = [];"));
     }
 }

app/core/src/test/java/stirling/software/SPDF/controller/api/converters/ConvertEmlToPDFTest.java

@@ -15,6 +15,7 @@ import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 
+import org.jboss.resteasy.reactive.multipart.FileUpload;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -23,16 +24,14 @@ import org.mockito.Mock;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.core.io.ByteArrayResource;
-import org.springframework.core.io.Resource;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
-import org.springframework.mock.web.MockMultipartFile;
+
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
 
 import stirling.software.common.configuration.RuntimePathConfig;
 import stirling.software.common.model.api.converters.EmlToPdfRequest;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.testsupport.TestFileUploads;
 import stirling.software.common.util.CustomHtmlSanitizer;
 import stirling.software.common.util.EmlToPdf;
 import stirling.software.common.util.TempFile;
@@ -41,16 +40,14 @@ import stirling.software.common.util.WebResponseUtils;
 
 @ExtendWith(MockitoExtension.class)
 class ConvertEmlToPDFTest {
-    private static ResponseEntity<Resource> streamingOk(byte[] bytes) {
-        return ResponseEntity.ok(new ByteArrayResource(bytes));
+
+    private static Response streamingOk(byte[] bytes) {
+        return Response.ok(bytes).build();
     }
 
-    private static byte[] drainBody(ResponseEntity<Resource> response) throws java.io.IOException {
-        java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
-        try (java.io.InputStream __in = response.getBody().getInputStream()) {
-            __in.transferTo(baos);
-        }
-        return baos.toByteArray();
+    private static byte[] bodyBytes(Response response) {
+        Object entity = response.getEntity();
+        return entity instanceof byte[] ? (byte[]) entity : new byte[0];
     }
 
     @Mock private CustomPDFDocumentFactory pdfDocumentFactory;
@@ -77,78 +74,58 @@ class ConvertEmlToPDFTest {
     }
 
     @Test
-    void convertEmlToPdf_emptyFileReturnsBadRequest() throws java.io.IOException {
-        MockMultipartFile emptyFile =
-                new MockMultipartFile("fileInput", "test.eml", "message/rfc822", new byte[0]);
+    void convertEmlToPdf_emptyFileReturnsBadRequest() {
+        FileUpload emptyFile = TestFileUploads.of(new byte[0], "test.eml", "message/rfc822");
 
-        EmlToPdfRequest request = new EmlToPdfRequest();
-        request.setFileInput(emptyFile);
+        Response response = controller.convertEmlToPdf(emptyFile, null, false, null, false, null);
 
-        ResponseEntity<Resource> response = controller.convertEmlToPdf(request);
-
-        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
         assertTrue(
-                new String(drainBody(response), StandardCharsets.UTF_8)
+                new String(bodyBytes(response), StandardCharsets.UTF_8)
                         .contains("No file provided"));
     }
 
     @Test
-    void convertEmlToPdf_nullFilenameReturnsBadRequest() throws java.io.IOException {
-        MockMultipartFile file =
-                new MockMultipartFile("fileInput", null, "message/rfc822", "content".getBytes());
+    void convertEmlToPdf_nullFilenameReturnsBadRequest() {
+        FileUpload file = TestFileUploads.of("content".getBytes(), null, "message/rfc822");
 
-        EmlToPdfRequest request = new EmlToPdfRequest();
-        request.setFileInput(file);
+        Response response = controller.convertEmlToPdf(file, null, false, null, false, null);
 
-        ResponseEntity<Resource> response = controller.convertEmlToPdf(request);
-
-        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
         assertTrue(
-                new String(drainBody(response), StandardCharsets.UTF_8).contains("valid filename"));
+                new String(bodyBytes(response), StandardCharsets.UTF_8).contains("valid filename"));
     }
 
     @Test
     void convertEmlToPdf_emptyFilenameReturnsBadRequest() {
-        MockMultipartFile file =
-                new MockMultipartFile("fileInput", "   ", "message/rfc822", "content".getBytes());
+        FileUpload file = TestFileUploads.of("content".getBytes(), "   ", "message/rfc822");
 
-        EmlToPdfRequest request = new EmlToPdfRequest();
-        request.setFileInput(file);
+        Response response = controller.convertEmlToPdf(file, null, false, null, false, null);
 
-        ResponseEntity<Resource> response = controller.convertEmlToPdf(request);
-
-        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
     }
 
     @Test
-    void convertEmlToPdf_invalidFileTypeReturnsBadRequest() throws java.io.IOException {
-        MockMultipartFile file =
-                new MockMultipartFile("fileInput", "test.txt", "text/plain", "content".getBytes());
+    void convertEmlToPdf_invalidFileTypeReturnsBadRequest() {
+        FileUpload file = TestFileUploads.of("content".getBytes(), "test.txt", "text/plain");
 
-        EmlToPdfRequest request = new EmlToPdfRequest();
-        request.setFileInput(file);
+        Response response = controller.convertEmlToPdf(file, null, false, null, false, null);
 
-        ResponseEntity<Resource> response = controller.convertEmlToPdf(request);
-
-        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
         assertTrue(
-                new String(drainBody(response), StandardCharsets.UTF_8)
+                new String(bodyBytes(response), StandardCharsets.UTF_8)
                         .contains("valid EML or MSG"));
     }
 
     @Test
     void convertEmlToPdf_successfulPdfConversion() throws Exception {
         byte[] pdfBytes = "fake-pdf-content".getBytes();
-        MockMultipartFile file =
-                new MockMultipartFile(
-                        "fileInput", "test.eml", "message/rfc822", "email content".getBytes());
-
-        EmlToPdfRequest request = new EmlToPdfRequest();
-        request.setFileInput(file);
+        FileUpload file =
+                TestFileUploads.of("email content".getBytes(), "test.eml", "message/rfc822");
 
         when(runtimePathConfig.getWeasyPrintPath()).thenReturn("/usr/bin/weasyprint");
 
-        ResponseEntity<Resource> expectedResponse = streamingOk(pdfBytes);
+        Response expectedResponse = streamingOk(pdfBytes);
 
         try (MockedStatic<EmlToPdf> emlMock = Mockito.mockStatic(EmlToPdf.class);
                 MockedStatic<WebResponseUtils> wrMock =
@@ -158,7 +135,7 @@ class ConvertEmlToPDFTest {
                             () ->
                                     EmlToPdf.convertEmlToPdf(
                                             eq("/usr/bin/weasyprint"),
-                                            eq(request),
+                                            any(EmlToPdfRequest.class),
                                             any(byte[].class),
                                             eq("test.eml"),
                                             eq(pdfDocumentFactory),
@@ -172,26 +149,20 @@ class ConvertEmlToPDFTest {
                                             any(TempFile.class), anyString()))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = controller.convertEmlToPdf(request);
+            Response response = controller.convertEmlToPdf(file, null, false, null, false, null);
 
-            assertEquals(HttpStatus.OK, response.getStatusCode());
-            assertArrayEquals(pdfBytes, drainBody(response));
+            assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+            assertArrayEquals(pdfBytes, bodyBytes(response));
         }
     }
 
     @Test
     void convertEmlToPdf_downloadHtmlMode() throws Exception {
         String htmlContent = "<html><body>email</body></html>";
-        MockMultipartFile file =
-                new MockMultipartFile(
-                        "fileInput", "test.eml", "message/rfc822", "email content".getBytes());
+        FileUpload file =
+                TestFileUploads.of("email content".getBytes(), "test.eml", "message/rfc822");
 
-        EmlToPdfRequest request = new EmlToPdfRequest();
-        request.setFileInput(file);
-        request.setDownloadHtml(true);
-
-        ResponseEntity<Resource> expectedResponse =
-                streamingOk(htmlContent.getBytes(StandardCharsets.UTF_8));
+        Response expectedResponse = streamingOk(htmlContent.getBytes(StandardCharsets.UTF_8));
 
         try (MockedStatic<EmlToPdf> emlMock = Mockito.mockStatic(EmlToPdf.class);
                 MockedStatic<WebResponseUtils> wrMock =
@@ -201,7 +172,7 @@ class ConvertEmlToPDFTest {
                             () ->
                                     EmlToPdf.convertEmlToHtml(
                                             any(byte[].class),
-                                            eq(request),
+                                            any(EmlToPdfRequest.class),
                                             eq(customHtmlSanitizer)))
                     .thenReturn(htmlContent);
 
@@ -211,21 +182,16 @@ class ConvertEmlToPDFTest {
                                             any(TempFile.class), anyString(), any(MediaType.class)))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = controller.convertEmlToPdf(request);
+            Response response = controller.convertEmlToPdf(file, null, false, null, true, null);
 
-            assertEquals(HttpStatus.OK, response.getStatusCode());
+            assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
         }
     }
 
     @Test
     void convertEmlToPdf_htmlConversionFailureReturnsError() throws Exception {
-        MockMultipartFile file =
-                new MockMultipartFile(
-                        "fileInput", "test.eml", "message/rfc822", "email content".getBytes());
-
-        EmlToPdfRequest request = new EmlToPdfRequest();
-        request.setFileInput(file);
-        request.setDownloadHtml(true);
+        FileUpload file =
+                TestFileUploads.of("email content".getBytes(), "test.eml", "message/rfc822");
 
         try (MockedStatic<EmlToPdf> emlMock = Mockito.mockStatic(EmlToPdf.class)) {
 
@@ -233,27 +199,24 @@ class ConvertEmlToPDFTest {
                             () ->
                                     EmlToPdf.convertEmlToHtml(
                                             any(byte[].class),
-                                            eq(request),
+                                            any(EmlToPdfRequest.class),
                                             eq(customHtmlSanitizer)))
                     .thenThrow(new IOException("Parse error"));
 
-            ResponseEntity<Resource> response = controller.convertEmlToPdf(request);
+            Response response = controller.convertEmlToPdf(file, null, false, null, true, null);
 
-            assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
+            assertEquals(
+                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatus());
             assertTrue(
-                    new String(drainBody(response), StandardCharsets.UTF_8)
+                    new String(bodyBytes(response), StandardCharsets.UTF_8)
                             .contains("HTML conversion failed"));
         }
     }
 
     @Test
     void convertEmlToPdf_nullPdfOutputReturnsError() throws Exception {
-        MockMultipartFile file =
-                new MockMultipartFile(
-                        "fileInput", "test.eml", "message/rfc822", "email content".getBytes());
-
-        EmlToPdfRequest request = new EmlToPdfRequest();
-        request.setFileInput(file);
+        FileUpload file =
+                TestFileUploads.of("email content".getBytes(), "test.eml", "message/rfc822");
 
         when(runtimePathConfig.getWeasyPrintPath()).thenReturn("/usr/bin/weasyprint");
 
@@ -265,11 +228,12 @@ class ConvertEmlToPDFTest {
                                             any(), any(), any(), any(), any(), any(), any()))
                     .thenReturn(null);
 
-            ResponseEntity<Resource> response = controller.convertEmlToPdf(request);
+            Response response = controller.convertEmlToPdf(file, null, false, null, false, null);
 
-            assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
+            assertEquals(
+                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatus());
             assertTrue(
-                    new String(drainBody(response), StandardCharsets.UTF_8)
+                    new String(bodyBytes(response), StandardCharsets.UTF_8)
                             .contains("empty output"));
         }
     }
@@ -277,19 +241,13 @@ class ConvertEmlToPDFTest {
     @Test
     void convertEmlToPdf_msgFileAccepted() throws Exception {
         byte[] pdfBytes = "fake-pdf".getBytes();
-        MockMultipartFile file =
-                new MockMultipartFile(
-                        "fileInput",
-                        "outlook.msg",
-                        "application/vnd.ms-outlook",
-                        "msg content".getBytes());
-
-        EmlToPdfRequest request = new EmlToPdfRequest();
-        request.setFileInput(file);
+        FileUpload file =
+                TestFileUploads.of(
+                        "msg content".getBytes(), "outlook.msg", "application/vnd.ms-outlook");
 
         when(runtimePathConfig.getWeasyPrintPath()).thenReturn("/usr/bin/weasyprint");
 
-        ResponseEntity<Resource> expectedResponse = streamingOk(pdfBytes);
+        Response expectedResponse = streamingOk(pdfBytes);
 
         try (MockedStatic<EmlToPdf> emlMock = Mockito.mockStatic(EmlToPdf.class);
                 MockedStatic<WebResponseUtils> wrMock =
@@ -307,20 +265,16 @@ class ConvertEmlToPDFTest {
                                             any(TempFile.class), anyString()))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = controller.convertEmlToPdf(request);
+            Response response = controller.convertEmlToPdf(file, null, false, null, false, null);
 
-            assertEquals(HttpStatus.OK, response.getStatusCode());
+            assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
         }
     }
 
     @Test
     void convertEmlToPdf_interruptedExceptionReturnsError() throws Exception {
-        MockMultipartFile file =
-                new MockMultipartFile(
-                        "fileInput", "test.eml", "message/rfc822", "email content".getBytes());
-
-        EmlToPdfRequest request = new EmlToPdfRequest();
-        request.setFileInput(file);
+        FileUpload file =
+                TestFileUploads.of("email content".getBytes(), "test.eml", "message/rfc822");
 
         when(runtimePathConfig.getWeasyPrintPath()).thenReturn("/usr/bin/weasyprint");
 
@@ -332,11 +286,12 @@ class ConvertEmlToPDFTest {
                                             any(), any(), any(), any(), any(), any(), any()))
                     .thenThrow(new InterruptedException("interrupted"));
 
-            ResponseEntity<Resource> response = controller.convertEmlToPdf(request);
+            Response response = controller.convertEmlToPdf(file, null, false, null, false, null);
 
-            assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
+            assertEquals(
+                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatus());
             assertTrue(
-                    new String(drainBody(response), StandardCharsets.UTF_8)
+                    new String(bodyBytes(response), StandardCharsets.UTF_8)
                             .contains("interrupted"));
         }
     }

app/core/src/test/java/stirling/software/SPDF/controller/api/converters/ConvertHtmlToPDFTest.java

@@ -12,6 +12,7 @@ import static org.mockito.Mockito.when;
 import java.io.File;
 import java.nio.file.Files;
 
+import org.jboss.resteasy.reactive.multipart.FileUpload;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -20,15 +21,13 @@ import org.mockito.Mock;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.core.io.ByteArrayResource;
-import org.springframework.core.io.Resource;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.mock.web.MockMultipartFile;
+
+import jakarta.ws.rs.core.Response;
 
 import stirling.software.common.configuration.RuntimePathConfig;
 import stirling.software.common.model.api.converters.HTMLToPdfRequest;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.testsupport.TestFileUploads;
 import stirling.software.common.util.CustomHtmlSanitizer;
 import stirling.software.common.util.FileToPdf;
 import stirling.software.common.util.GeneralUtils;
@@ -38,16 +37,9 @@ import stirling.software.common.util.WebResponseUtils;
 
 @ExtendWith(MockitoExtension.class)
 class ConvertHtmlToPDFTest {
-    private static ResponseEntity<Resource> streamingOk(byte[] bytes) {
-        return ResponseEntity.ok(new ByteArrayResource(bytes));
-    }
 
-    private static byte[] drainBody(ResponseEntity<Resource> response) throws java.io.IOException {
-        java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
-        try (java.io.InputStream __in = response.getBody().getInputStream()) {
-            __in.transferTo(baos);
-        }
-        return baos.toByteArray();
+    private static Response streamingOk(byte[] bytes) {
+        return Response.ok(bytes).build();
     }
 
     @Mock private CustomPDFDocumentFactory pdfDocumentFactory;
@@ -75,20 +67,14 @@ class ConvertHtmlToPDFTest {
 
     @Test
     void htmlToPdf_nullFileInputThrows() {
-        HTMLToPdfRequest request = new HTMLToPdfRequest();
-        request.setFileInput(null);
-
-        assertThrows(Exception.class, () -> controller.HtmlToPdf(request));
+        assertThrows(Exception.class, () -> controller.HtmlToPdf(null, null, 1f));
     }
 
     @Test
     void htmlToPdf_invalidExtensionThrows() {
-        MockMultipartFile file =
-                new MockMultipartFile("fileInput", "test.txt", "text/plain", "content".getBytes());
-        HTMLToPdfRequest request = new HTMLToPdfRequest();
-        request.setFileInput(file);
+        FileUpload file = TestFileUploads.of("content".getBytes(), "test.txt", "text/plain");
 
-        assertThrows(Exception.class, () -> controller.HtmlToPdf(request));
+        assertThrows(Exception.class, () -> controller.HtmlToPdf(file, null, 1f));
     }
 
     @Test
@@ -97,16 +83,13 @@ class ConvertHtmlToPDFTest {
         byte[] pdfBytes = "pdf-content".getBytes();
         byte[] processedPdf = "processed-pdf".getBytes();
 
-        MockMultipartFile file =
-                new MockMultipartFile("fileInput", "test.html", "text/html", htmlContent);
-        HTMLToPdfRequest request = new HTMLToPdfRequest();
-        request.setFileInput(file);
+        FileUpload file = TestFileUploads.of(htmlContent, "test.html", "text/html");
 
         when(runtimePathConfig.getWeasyPrintPath()).thenReturn("/usr/bin/weasyprint");
         when(pdfDocumentFactory.createNewBytesBasedOnOldDocument(pdfBytes))
                 .thenReturn(processedPdf);
 
-        ResponseEntity<Resource> expectedResponse = streamingOk(processedPdf);
+        Response expectedResponse = streamingOk(processedPdf);
 
         try (MockedStatic<FileToPdf> ftpMock = Mockito.mockStatic(FileToPdf.class);
                 MockedStatic<GeneralUtils> guMock = Mockito.mockStatic(GeneralUtils.class);
@@ -117,7 +100,7 @@ class ConvertHtmlToPDFTest {
                             () ->
                                     FileToPdf.convertHtmlToPdf(
                                             eq("/usr/bin/weasyprint"),
-                                            eq(request),
+                                            any(HTMLToPdfRequest.class),
                                             any(byte[].class),
                                             eq("test.html"),
                                             eq(tempFileManager),
@@ -133,9 +116,9 @@ class ConvertHtmlToPDFTest {
                                             any(TempFile.class), anyString()))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = controller.HtmlToPdf(request);
+            Response response = controller.HtmlToPdf(file, null, 1f);
 
-            assertEquals(HttpStatus.OK, response.getStatusCode());
+            assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
         }
     }
 
@@ -145,16 +128,13 @@ class ConvertHtmlToPDFTest {
         byte[] pdfBytes = "pdf-content".getBytes();
         byte[] processedPdf = "processed-pdf".getBytes();
 
-        MockMultipartFile file =
-                new MockMultipartFile("fileInput", "archive.zip", "application/zip", zipContent);
-        HTMLToPdfRequest request = new HTMLToPdfRequest();
-        request.setFileInput(file);
+        FileUpload file = TestFileUploads.of(zipContent, "archive.zip", "application/zip");
 
         when(runtimePathConfig.getWeasyPrintPath()).thenReturn("/usr/bin/weasyprint");
         when(pdfDocumentFactory.createNewBytesBasedOnOldDocument(pdfBytes))
                 .thenReturn(processedPdf);
 
-        ResponseEntity<Resource> expectedResponse = streamingOk(processedPdf);
+        Response expectedResponse = streamingOk(processedPdf);
 
         try (MockedStatic<FileToPdf> ftpMock = Mockito.mockStatic(FileToPdf.class);
                 MockedStatic<GeneralUtils> guMock = Mockito.mockStatic(GeneralUtils.class);
@@ -165,7 +145,7 @@ class ConvertHtmlToPDFTest {
                             () ->
                                     FileToPdf.convertHtmlToPdf(
                                             eq("/usr/bin/weasyprint"),
-                                            eq(request),
+                                            any(HTMLToPdfRequest.class),
                                             any(byte[].class),
                                             eq("archive.zip"),
                                             eq(tempFileManager),
@@ -181,19 +161,16 @@ class ConvertHtmlToPDFTest {
                                             any(TempFile.class), anyString()))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = controller.HtmlToPdf(request);
+            Response response = controller.HtmlToPdf(file, null, 1f);
 
-            assertEquals(HttpStatus.OK, response.getStatusCode());
+            assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
         }
     }
 
     @Test
     void htmlToPdf_nullFilenameThrows() {
-        MockMultipartFile file =
-                new MockMultipartFile("fileInput", null, "text/html", "content".getBytes());
-        HTMLToPdfRequest request = new HTMLToPdfRequest();
-        request.setFileInput(file);
+        FileUpload file = TestFileUploads.of("content".getBytes(), null, "text/html");
 
-        assertThrows(Exception.class, () -> controller.HtmlToPdf(request));
+        assertThrows(Exception.class, () -> controller.HtmlToPdf(file, null, 1f));
     }
 }

app/core/src/test/java/stirling/software/SPDF/controller/api/converters/ConvertMarkdownToPdfTest.java

@@ -14,6 +14,7 @@ import static org.mockito.Mockito.when;
 import java.io.File;
 import java.nio.file.Files;
 
+import org.jboss.resteasy.reactive.multipart.FileUpload;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -22,15 +23,12 @@ import org.mockito.Mock;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.core.io.ByteArrayResource;
-import org.springframework.core.io.Resource;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.mock.web.MockMultipartFile;
+
+import jakarta.ws.rs.core.Response;
 
 import stirling.software.common.configuration.RuntimePathConfig;
-import stirling.software.common.model.api.GeneralFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.testsupport.TestFileUploads;
 import stirling.software.common.util.CustomHtmlSanitizer;
 import stirling.software.common.util.FileToPdf;
 import stirling.software.common.util.GeneralUtils;
@@ -40,16 +38,9 @@ import stirling.software.common.util.WebResponseUtils;
 
 @ExtendWith(MockitoExtension.class)
 class ConvertMarkdownToPdfTest {
-    private static ResponseEntity<Resource> streamingOk(byte[] bytes) {
-        return ResponseEntity.ok(new ByteArrayResource(bytes));
-    }
 
-    private static byte[] drainBody(ResponseEntity<Resource> response) throws java.io.IOException {
-        java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
-        try (java.io.InputStream __in = response.getBody().getInputStream()) {
-            __in.transferTo(baos);
-        }
-        return baos.toByteArray();
+    private static Response streamingOk(byte[] bytes) {
+        return Response.ok(bytes).build();
     }
 
     @Mock private CustomPDFDocumentFactory pdfDocumentFactory;
@@ -77,20 +68,14 @@ class ConvertMarkdownToPdfTest {
 
     @Test
     void markdownToPdf_nullFileInputThrows() {
-        GeneralFile generalFile = new GeneralFile();
-        generalFile.setFileInput(null);
-
-        assertThrows(Exception.class, () -> controller.markdownToPdf(generalFile));
+        assertThrows(Exception.class, () -> controller.markdownToPdf(null));
     }
 
     @Test
     void markdownToPdf_invalidExtensionThrows() {
-        MockMultipartFile file =
-                new MockMultipartFile("fileInput", "test.txt", "text/plain", "content".getBytes());
-        GeneralFile generalFile = new GeneralFile();
-        generalFile.setFileInput(file);
+        FileUpload file = TestFileUploads.of("content".getBytes(), "test.txt", "text/plain");
 
-        assertThrows(Exception.class, () -> controller.markdownToPdf(generalFile));
+        assertThrows(Exception.class, () -> controller.markdownToPdf(file));
     }
 
     @Test
@@ -99,16 +84,13 @@ class ConvertMarkdownToPdfTest {
         byte[] pdfBytes = "pdf-content".getBytes();
         byte[] processedPdf = "processed-pdf".getBytes();
 
-        MockMultipartFile file =
-                new MockMultipartFile("fileInput", "readme.md", "text/markdown", mdContent);
-        GeneralFile generalFile = new GeneralFile();
-        generalFile.setFileInput(file);
+        FileUpload file = TestFileUploads.of(mdContent, "readme.md", "text/markdown");
 
         when(runtimePathConfig.getWeasyPrintPath()).thenReturn("/usr/bin/weasyprint");
         when(pdfDocumentFactory.createNewBytesBasedOnOldDocument(any(byte[].class)))
                 .thenReturn(processedPdf);
 
-        ResponseEntity<Resource> expectedResponse = streamingOk(processedPdf);
+        Response expectedResponse = streamingOk(processedPdf);
 
         try (MockedStatic<FileToPdf> ftpMock = Mockito.mockStatic(FileToPdf.class);
                 MockedStatic<GeneralUtils> guMock = Mockito.mockStatic(GeneralUtils.class);
@@ -135,20 +117,17 @@ class ConvertMarkdownToPdfTest {
                                             any(TempFile.class), anyString()))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = controller.markdownToPdf(generalFile);
+            Response response = controller.markdownToPdf(file);
 
-            assertEquals(HttpStatus.OK, response.getStatusCode());
+            assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
         }
     }
 
     @Test
     void markdownToPdf_nullFilenameThrows() {
-        MockMultipartFile file =
-                new MockMultipartFile("fileInput", null, "text/markdown", "# Title".getBytes());
-        GeneralFile generalFile = new GeneralFile();
-        generalFile.setFileInput(file);
+        FileUpload file = TestFileUploads.of("# Title".getBytes(), null, "text/markdown");
 
-        assertThrows(Exception.class, () -> controller.markdownToPdf(generalFile));
+        assertThrows(Exception.class, () -> controller.markdownToPdf(file));
     }
 
     @Test

app/core/src/test/java/stirling/software/SPDF/controller/api/converters/ConvertPDFToOfficeTest.java

@@ -13,6 +13,7 @@ import java.io.File;
 import java.nio.file.Files;
 
 import org.apache.pdfbox.pdmodel.PDDocument;
+import org.jboss.resteasy.reactive.multipart.FileUpload;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -21,37 +22,26 @@ import org.mockito.Mock;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.core.io.ByteArrayResource;
-import org.springframework.core.io.Resource;
-import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
-import org.springframework.mock.web.MockMultipartFile;
+
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
 
 import stirling.software.SPDF.model.api.converters.PdfToPresentationRequest;
 import stirling.software.SPDF.model.api.converters.PdfToTextOrRTFRequest;
 import stirling.software.SPDF.model.api.converters.PdfToWordRequest;
 import stirling.software.common.configuration.RuntimePathConfig;
+import stirling.software.common.model.MultipartFile;
 import stirling.software.common.model.api.PDFFile;
+import stirling.software.common.model.multipart.ByteArrayMultipartFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.testsupport.TestFileUploads;
 import stirling.software.common.util.GeneralUtils;
-import stirling.software.common.util.PDFToFile;
 import stirling.software.common.util.TempFile;
 import stirling.software.common.util.TempFileManager;
 import stirling.software.common.util.WebResponseUtils;
 
 @ExtendWith(MockitoExtension.class)
 class ConvertPDFToOfficeTest {
-    private static ResponseEntity<Resource> streamingOk(byte[] bytes) {
-        return ResponseEntity.ok(new ByteArrayResource(bytes));
-    }
-
-    private static byte[] drainBody(ResponseEntity<Resource> response) throws java.io.IOException {
-        java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
-        try (java.io.InputStream __in = response.getBody().getInputStream()) {
-            __in.transferTo(baos);
-        }
-        return baos.toByteArray();
-    }
 
     @Mock private CustomPDFDocumentFactory pdfDocumentFactory;
     @Mock private TempFileManager tempFileManager;
@@ -75,48 +65,37 @@ class ConvertPDFToOfficeTest {
                         });
     }
 
-    private MockMultipartFile createPdfFile() {
-        return new MockMultipartFile(
+    private FileUpload createPdfUpload() {
+        return TestFileUploads.of("pdf-content".getBytes(), "document.pdf", "application/pdf");
+    }
+
+    private MultipartFile createPdfFile() {
+        return new ByteArrayMultipartFile(
                 "fileInput", "document.pdf", "application/pdf", "pdf-content".getBytes());
     }
 
     @Test
-    void processPdfToPresentation_delegatesToPdfToFile() throws Exception {
-        MockMultipartFile pdfFile = createPdfFile();
+    void processPdfToPresentation_delegatesToPdfToFile() {
         PdfToPresentationRequest request = new PdfToPresentationRequest();
-        request.setFileInput(pdfFile);
+        request.setFileInput(createPdfFile());
         request.setOutputFormat("pptx");
 
-        ResponseEntity<Resource> expectedResponse = streamingOk("pptx-content".getBytes());
-
-        try (MockedStatic<PDFToFile> mock =
-                Mockito.mockStatic(PDFToFile.class, Mockito.CALLS_REAL_METHODS)) {
-            PDFToFile pdfToFile = Mockito.mock(PDFToFile.class);
-
-            // We can't easily mock the constructor, so test via the actual endpoint
-            // which creates PDFToFile internally. Instead, verify the method doesn't throw
-            // with proper mocking of the utility.
-        }
-
-        // Since PDFToFile is created internally (not injected), we verify
-        // by checking that the method runs without NPE and exercises the code path
+        // PDFToFile is created internally (not injected) and shells out to LibreOffice, so the
+        // happy path is covered by integration tests. Here we assert the request wiring only.
         assertNotNull(request.getOutputFormat());
         assertEquals("pptx", request.getOutputFormat());
     }
 
     @Test
     void processPdfToRTForTXT_withTxtFormat_usesStripper() throws Exception {
-        MockMultipartFile pdfFile = createPdfFile();
-        PdfToTextOrRTFRequest request = new PdfToTextOrRTFRequest();
-        request.setFileInput(pdfFile);
-        request.setOutputFormat("txt");
+        FileUpload pdfFile = createPdfUpload();
 
         // Use a real PDDocument so PDFTextStripper.getText() works without NPE
         PDDocument realDoc = new PDDocument();
         realDoc.addPage(new org.apache.pdfbox.pdmodel.PDPage());
-        when(pdfDocumentFactory.load(pdfFile)).thenReturn(realDoc);
+        when(pdfDocumentFactory.load(any(MultipartFile.class))).thenReturn(realDoc);
 
-        ResponseEntity<Resource> expectedResponse = streamingOk("text content".getBytes());
+        Response expectedResponse = Response.ok("text content".getBytes()).build();
 
         try (MockedStatic<GeneralUtils> guMock = Mockito.mockStatic(GeneralUtils.class);
                 MockedStatic<WebResponseUtils> wrMock =
@@ -131,7 +110,7 @@ class ConvertPDFToOfficeTest {
                                             any(TempFile.class), anyString(), any(MediaType.class)))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = controller.processPdfToRTForTXT(request);
+            Response response = controller.processPdfToRTForTXT(pdfFile, "txt");
 
             assertSame(expectedResponse, response);
         }
@@ -161,8 +140,7 @@ class ConvertPDFToOfficeTest {
     @Test
     void processPdfToXML_delegatesCorrectly() {
         PDFFile file = new PDFFile();
-        MockMultipartFile pdfFile = createPdfFile();
-        file.setFileInput(pdfFile);
+        file.setFileInput(createPdfFile());
         assertNotNull(file.getFileInput());
     }
 }

app/core/src/test/java/stirling/software/SPDF/controller/api/converters/ConvertSvgToPDFTest.java

@@ -12,7 +12,9 @@ import java.io.File;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.util.List;
 
+import org.jboss.resteasy.reactive.multipart.FileUpload;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -21,15 +23,12 @@ import org.mockito.Mock;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.core.io.ByteArrayResource;
-import org.springframework.core.io.Resource;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.mock.web.MockMultipartFile;
 
-import stirling.software.SPDF.model.api.converters.SvgToPdfRequest;
+import jakarta.ws.rs.core.Response;
+
 import stirling.software.SPDF.utils.SvgToPdf;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.testsupport.TestFileUploads;
 import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.SvgSanitizer;
 import stirling.software.common.util.TempFile;
@@ -38,16 +37,14 @@ import stirling.software.common.util.WebResponseUtils;
 
 @ExtendWith(MockitoExtension.class)
 class ConvertSvgToPDFTest {
-    private static ResponseEntity<Resource> streamingOk(byte[] bytes) {
-        return ResponseEntity.ok(new ByteArrayResource(bytes));
+
+    private static Response streamingOk(byte[] bytes) {
+        return Response.ok(bytes).build();
     }
 
-    private static byte[] drainBody(ResponseEntity<Resource> response) throws java.io.IOException {
-        java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
-        try (java.io.InputStream __in = response.getBody().getInputStream()) {
-            __in.transferTo(baos);
-        }
-        return baos.toByteArray();
+    private static byte[] bodyBytes(Response response) {
+        Object entity = response.getEntity();
+        return entity instanceof byte[] ? (byte[]) entity : new byte[0];
     }
 
     @Mock private CustomPDFDocumentFactory pdfDocumentFactory;
@@ -73,56 +70,40 @@ class ConvertSvgToPDFTest {
     }
 
     @Test
-    void convertSvgToPdf_nullFilesReturnsBadRequest() throws java.io.IOException {
-        SvgToPdfRequest request = new SvgToPdfRequest();
-        request.setFileInput(null);
+    void convertSvgToPdf_nullFilesReturnsBadRequest() {
+        Response response = controller.convertSvgToPdf(null, false);
 
-        ResponseEntity<Resource> response = controller.convertSvgToPdf(request);
-
-        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
         assertTrue(
-                new String(drainBody(response), StandardCharsets.UTF_8)
+                new String(bodyBytes(response), StandardCharsets.UTF_8)
                         .contains("No files provided"));
     }
 
     @Test
     void convertSvgToPdf_emptyFilesArrayReturnsBadRequest() {
-        SvgToPdfRequest request = new SvgToPdfRequest();
-        request.setFileInput(new MockMultipartFile[0]);
+        Response response = controller.convertSvgToPdf(List.of(), false);
 
-        ResponseEntity<Resource> response = controller.convertSvgToPdf(request);
-
-        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
     }
 
     @Test
-    void convertSvgToPdf_nonSvgFileSkipped() throws IOException {
-        MockMultipartFile txtFile =
-                new MockMultipartFile("fileInput", "test.txt", "text/plain", "content".getBytes());
+    void convertSvgToPdf_nonSvgFileSkipped() {
+        FileUpload txtFile = TestFileUploads.of("content".getBytes(), "test.txt", "text/plain");
 
-        SvgToPdfRequest request = new SvgToPdfRequest();
-        request.setFileInput(new MockMultipartFile[] {txtFile});
-        request.setCombineIntoSinglePdf(false);
+        Response response = controller.convertSvgToPdf(List.of(txtFile), false);
 
-        ResponseEntity<Resource> response = controller.convertSvgToPdf(request);
-
-        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
         assertTrue(
-                new String(drainBody(response), StandardCharsets.UTF_8).contains("No valid SVG"));
+                new String(bodyBytes(response), StandardCharsets.UTF_8).contains("No valid SVG"));
     }
 
     @Test
-    void convertSvgToPdf_emptyFileSkipped() throws IOException {
-        MockMultipartFile emptyFile =
-                new MockMultipartFile("fileInput", "test.svg", "image/svg+xml", new byte[0]);
+    void convertSvgToPdf_emptyFileSkipped() {
+        FileUpload emptyFile = TestFileUploads.of(new byte[0], "test.svg", "image/svg+xml");
 
-        SvgToPdfRequest request = new SvgToPdfRequest();
-        request.setFileInput(new MockMultipartFile[] {emptyFile});
-        request.setCombineIntoSinglePdf(false);
+        Response response = controller.convertSvgToPdf(List.of(emptyFile), false);
 
-        ResponseEntity<Resource> response = controller.convertSvgToPdf(request);
-
-        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
     }
 
     @Test
@@ -132,18 +113,15 @@ class ConvertSvgToPDFTest {
         byte[] pdfBytes = "pdf-output".getBytes();
         byte[] processedPdf = "processed-pdf".getBytes();
 
-        MockMultipartFile svgFile =
-                new MockMultipartFile("fileInput", "drawing.svg", "image/svg+xml", svgContent);
+        FileUpload svgFile = TestFileUploads.of(svgContent, "drawing.svg", "image/svg+xml");
 
-        SvgToPdfRequest request = new SvgToPdfRequest();
-        request.setFileInput(new MockMultipartFile[] {svgFile});
-        request.setCombineIntoSinglePdf(false);
-
-        when(svgSanitizer.sanitize(svgContent)).thenReturn(sanitizedSvg);
+        // FileUploadMultipartFile#getBytes() re-reads from disk, so the byte[] handed to the
+        // sanitizer is a fresh copy (byte[] equality is identity) - match on type, not value.
+        when(svgSanitizer.sanitize(any(byte[].class))).thenReturn(sanitizedSvg);
         when(pdfDocumentFactory.createNewBytesBasedOnOldDocument(pdfBytes))
                 .thenReturn(processedPdf);
 
-        ResponseEntity<Resource> expectedResponse = streamingOk(processedPdf);
+        Response expectedResponse = streamingOk(processedPdf);
 
         try (MockedStatic<SvgToPdf> svgMock = Mockito.mockStatic(SvgToPdf.class);
                 MockedStatic<GeneralUtils> guMock = Mockito.mockStatic(GeneralUtils.class);
@@ -161,9 +139,9 @@ class ConvertSvgToPDFTest {
                                             any(TempFile.class), anyString()))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = controller.convertSvgToPdf(request);
+            Response response = controller.convertSvgToPdf(List.of(svgFile), false);
 
-            assertEquals(HttpStatus.OK, response.getStatusCode());
+            assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
         }
     }
 
@@ -171,26 +149,19 @@ class ConvertSvgToPDFTest {
     void convertSvgToPdf_combinedMode() throws Exception {
         byte[] svgContent1 = "<svg>1</svg>".getBytes();
         byte[] svgContent2 = "<svg>2</svg>".getBytes();
-        byte[] sanitizedSvg1 = "<svg>s1</svg>".getBytes();
-        byte[] sanitizedSvg2 = "<svg>s2</svg>".getBytes();
+        byte[] sanitizedSvg = "<svg>s</svg>".getBytes();
         byte[] combinedPdf = "combined-pdf".getBytes();
         byte[] processedPdf = "processed-combined".getBytes();
 
-        MockMultipartFile svgFile1 =
-                new MockMultipartFile("fileInput", "a.svg", "image/svg+xml", svgContent1);
-        MockMultipartFile svgFile2 =
-                new MockMultipartFile("fileInput", "b.svg", "image/svg+xml", svgContent2);
+        FileUpload svgFile1 = TestFileUploads.of(svgContent1, "a.svg", "image/svg+xml");
+        FileUpload svgFile2 = TestFileUploads.of(svgContent2, "b.svg", "image/svg+xml");
 
-        SvgToPdfRequest request = new SvgToPdfRequest();
-        request.setFileInput(new MockMultipartFile[] {svgFile1, svgFile2});
-        request.setCombineIntoSinglePdf(true);
-
-        when(svgSanitizer.sanitize(svgContent1)).thenReturn(sanitizedSvg1);
-        when(svgSanitizer.sanitize(svgContent2)).thenReturn(sanitizedSvg2);
+        // Sanitizer output only feeds SvgToPdf.combineIntoPdf(any()), which ignores the value here.
+        when(svgSanitizer.sanitize(any(byte[].class))).thenReturn(sanitizedSvg);
         when(pdfDocumentFactory.createNewBytesBasedOnOldDocument(combinedPdf))
                 .thenReturn(processedPdf);
 
-        ResponseEntity<Resource> expectedResponse = streamingOk(processedPdf);
+        Response expectedResponse = streamingOk(processedPdf);
 
         try (MockedStatic<SvgToPdf> svgMock = Mockito.mockStatic(SvgToPdf.class);
                 MockedStatic<GeneralUtils> guMock = Mockito.mockStatic(GeneralUtils.class);
@@ -208,40 +179,31 @@ class ConvertSvgToPDFTest {
                                             any(TempFile.class), anyString()))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = controller.convertSvgToPdf(request);
+            Response response = controller.convertSvgToPdf(List.of(svgFile1, svgFile2), true);
 
-            assertEquals(HttpStatus.OK, response.getStatusCode());
+            assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
         }
     }
 
     @Test
-    void convertSvgToPdf_nullFilenameSkipped() throws IOException {
-        MockMultipartFile nullNameFile =
-                new MockMultipartFile("fileInput", null, "image/svg+xml", "svg".getBytes());
+    void convertSvgToPdf_nullFilenameSkipped() {
+        FileUpload nullNameFile = TestFileUploads.of("svg".getBytes(), null, "image/svg+xml");
 
-        SvgToPdfRequest request = new SvgToPdfRequest();
-        request.setFileInput(new MockMultipartFile[] {nullNameFile});
-        request.setCombineIntoSinglePdf(false);
+        Response response = controller.convertSvgToPdf(List.of(nullNameFile), false);
 
-        ResponseEntity<Resource> response = controller.convertSvgToPdf(request);
-
-        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
     }
 
     @Test
     void convertSvgToPdf_sanitizationFailureSkipsFile() throws IOException {
         byte[] svgContent = "<svg>bad</svg>".getBytes();
-        MockMultipartFile svgFile =
-                new MockMultipartFile("fileInput", "bad.svg", "image/svg+xml", svgContent);
+        FileUpload svgFile = TestFileUploads.of(svgContent, "bad.svg", "image/svg+xml");
 
-        SvgToPdfRequest request = new SvgToPdfRequest();
-        request.setFileInput(new MockMultipartFile[] {svgFile});
-        request.setCombineIntoSinglePdf(false);
+        when(svgSanitizer.sanitize(any(byte[].class)))
+                .thenThrow(new IOException("sanitization error"));
 
-        when(svgSanitizer.sanitize(svgContent)).thenThrow(new IOException("sanitization error"));
+        Response response = controller.convertSvgToPdf(List.of(svgFile), false);
 
-        ResponseEntity<Resource> response = controller.convertSvgToPdf(request);
-
-        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
     }
 }

app/core/src/test/java/stirling/software/SPDF/controller/api/misc/ShowJavascriptTest.java

@@ -1,8 +1,14 @@
 package stirling.software.SPDF.controller.api.misc;
 
 import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.*;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
 
 import java.io.File;
 import java.nio.file.Files;
@@ -12,6 +18,7 @@ import org.apache.pdfbox.pdmodel.PDDocumentCatalog;
 import org.apache.pdfbox.pdmodel.PDDocumentNameDictionary;
 import org.apache.pdfbox.pdmodel.PDJavascriptNameTreeNode;
 import org.apache.pdfbox.pdmodel.interactive.action.PDActionJavaScript;
+import org.jboss.resteasy.reactive.multipart.FileUpload;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -19,40 +26,26 @@ import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockedStatic;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.core.io.ByteArrayResource;
-import org.springframework.core.io.Resource;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
-import org.springframework.mock.web.MockMultipartFile;
 
-import stirling.software.common.model.api.PDFFile;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+
+import stirling.software.common.model.MultipartFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.testsupport.TestFileUploads;
 import stirling.software.common.util.TempFile;
 import stirling.software.common.util.TempFileManager;
 import stirling.software.common.util.WebResponseUtils;
 
 @ExtendWith(MockitoExtension.class)
 class ShowJavascriptTest {
-    private static ResponseEntity<Resource> streamingOk(byte[] bytes) {
-        return ResponseEntity.ok(new ByteArrayResource(bytes));
-    }
-
-    private static byte[] drainBody(ResponseEntity<Resource> response) throws java.io.IOException {
-        java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
-        try (java.io.InputStream __in = response.getBody().getInputStream()) {
-            __in.transferTo(baos);
-        }
-        return baos.toByteArray();
-    }
 
     @Mock private CustomPDFDocumentFactory pdfDocumentFactory;
     @Mock private TempFileManager tempFileManager;
 
     @InjectMocks private ShowJavascript showJavascript;
 
-    private MockMultipartFile pdfFile;
-    private PDFFile request;
+    private FileUpload pdfFile;
 
     @BeforeEach
     void setUp() throws Exception {
@@ -68,14 +61,7 @@ class ShowJavascriptTest {
                             lenient().when(tf.getPath()).thenReturn(f.toPath());
                             return tf;
                         });
-        pdfFile =
-                new MockMultipartFile(
-                        "fileInput",
-                        "test.pdf",
-                        MediaType.APPLICATION_PDF_VALUE,
-                        "PDF content".getBytes());
-        request = new PDFFile();
-        request.setFileInput(pdfFile);
+        pdfFile = TestFileUploads.pdf("PDF content".getBytes());
     }
 
     @Test
@@ -84,30 +70,30 @@ class ShowJavascriptTest {
         PDDocumentCatalog catalog = mock(PDDocumentCatalog.class);
         when(mockDoc.getDocumentCatalog()).thenReturn(catalog);
         when(catalog.getNames()).thenReturn(null);
-        when(pdfDocumentFactory.load(pdfFile)).thenReturn(mockDoc);
+        when(pdfDocumentFactory.load(any(MultipartFile.class))).thenReturn(mockDoc);
 
         try (MockedStatic<WebResponseUtils> mockedWebResponse =
                 mockStatic(WebResponseUtils.class)) {
-            ResponseEntity<Resource> expectedResponse = streamingOk("no js".getBytes());
+            Response expectedResponse = Response.ok("no js".getBytes()).build();
             mockedWebResponse
                     .when(
                             () ->
                                     WebResponseUtils.fileToWebResponse(
                                             any(TempFile.class),
                                             eq("test.pdf.js"),
-                                            eq(MediaType.TEXT_PLAIN)))
+                                            eq(MediaType.TEXT_PLAIN_TYPE)))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = showJavascript.extractHeader(request);
+            Response response = showJavascript.extractHeader(pdfFile, null);
 
             assertNotNull(response);
-            assertEquals(HttpStatus.OK, response.getStatusCode());
+            assertEquals(200, response.getStatus());
             mockedWebResponse.verify(
                     () ->
                             WebResponseUtils.fileToWebResponse(
                                     any(TempFile.class),
                                     eq("test.pdf.js"),
-                                    eq(MediaType.TEXT_PLAIN)));
+                                    eq(MediaType.TEXT_PLAIN_TYPE)));
         }
     }
 
@@ -126,21 +112,21 @@ class ShowJavascriptTest {
         doReturn(jsTree).when(nameDict).getJavaScript();
         java.util.Map<String, PDActionJavaScript> jsMap = java.util.Map.of("Script1", jsAction);
         when(jsTree.getNames()).thenReturn(jsMap);
-        when(pdfDocumentFactory.load(pdfFile)).thenReturn(mockDoc);
+        when(pdfDocumentFactory.load(any(MultipartFile.class))).thenReturn(mockDoc);
 
         try (MockedStatic<WebResponseUtils> mockedWebResponse =
                 mockStatic(WebResponseUtils.class)) {
-            ResponseEntity<Resource> expectedResponse = streamingOk("js content".getBytes());
+            Response expectedResponse = Response.ok("js content".getBytes()).build();
             mockedWebResponse
                     .when(
                             () ->
                                     WebResponseUtils.fileToWebResponse(
                                             any(TempFile.class),
                                             eq("test.pdf.js"),
-                                            eq(MediaType.TEXT_PLAIN)))
+                                            eq(MediaType.TEXT_PLAIN_TYPE)))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = showJavascript.extractHeader(request);
+            Response response = showJavascript.extractHeader(pdfFile, null);
 
             assertNotNull(response);
             mockedWebResponse.verify(
@@ -148,7 +134,7 @@ class ShowJavascriptTest {
                             WebResponseUtils.fileToWebResponse(
                                     any(TempFile.class),
                                     eq("test.pdf.js"),
-                                    eq(MediaType.TEXT_PLAIN)));
+                                    eq(MediaType.TEXT_PLAIN_TYPE)));
         }
     }
 
@@ -156,27 +142,29 @@ class ShowJavascriptTest {
     void extractHeader_nullCatalog_returnsNoJsMessage() throws Exception {
         PDDocument mockDoc = mock(PDDocument.class);
         when(mockDoc.getDocumentCatalog()).thenReturn(null);
-        when(pdfDocumentFactory.load(pdfFile)).thenReturn(mockDoc);
+        when(pdfDocumentFactory.load(any(MultipartFile.class))).thenReturn(mockDoc);
 
         try (MockedStatic<WebResponseUtils> mockedWebResponse =
                 mockStatic(WebResponseUtils.class)) {
-            ResponseEntity<Resource> expectedResponse = streamingOk("no js".getBytes());
+            Response expectedResponse = Response.ok("no js".getBytes()).build();
             mockedWebResponse
                     .when(
                             () ->
                                     WebResponseUtils.fileToWebResponse(
                                             any(TempFile.class),
                                             anyString(),
-                                            eq(MediaType.TEXT_PLAIN)))
+                                            eq(MediaType.TEXT_PLAIN_TYPE)))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = showJavascript.extractHeader(request);
+            Response response = showJavascript.extractHeader(pdfFile, null);
 
             assertNotNull(response);
             mockedWebResponse.verify(
                     () ->
                             WebResponseUtils.fileToWebResponse(
-                                    any(TempFile.class), anyString(), eq(MediaType.TEXT_PLAIN)));
+                                    any(TempFile.class),
+                                    anyString(),
+                                    eq(MediaType.TEXT_PLAIN_TYPE)));
         }
     }
 
@@ -195,34 +183,37 @@ class ShowJavascriptTest {
         doReturn(jsTree).when(nameDict).getJavaScript();
         java.util.Map<String, PDActionJavaScript> jsMap2 = java.util.Map.of("Script1", jsAction);
         when(jsTree.getNames()).thenReturn(jsMap2);
-        when(pdfDocumentFactory.load(pdfFile)).thenReturn(mockDoc);
+        when(pdfDocumentFactory.load(any(MultipartFile.class))).thenReturn(mockDoc);
 
         try (MockedStatic<WebResponseUtils> mockedWebResponse =
                 mockStatic(WebResponseUtils.class)) {
-            ResponseEntity<Resource> expectedResponse = streamingOk("no js".getBytes());
+            Response expectedResponse = Response.ok("no js".getBytes()).build();
             mockedWebResponse
                     .when(
                             () ->
                                     WebResponseUtils.fileToWebResponse(
                                             any(TempFile.class),
                                             anyString(),
-                                            eq(MediaType.TEXT_PLAIN)))
+                                            eq(MediaType.TEXT_PLAIN_TYPE)))
                     .thenReturn(expectedResponse);
 
-            ResponseEntity<Resource> response = showJavascript.extractHeader(request);
+            Response response = showJavascript.extractHeader(pdfFile, null);
 
             assertNotNull(response);
             mockedWebResponse.verify(
                     () ->
                             WebResponseUtils.fileToWebResponse(
-                                    any(TempFile.class), anyString(), eq(MediaType.TEXT_PLAIN)));
+                                    any(TempFile.class),
+                                    anyString(),
+                                    eq(MediaType.TEXT_PLAIN_TYPE)));
         }
     }
 
     @Test
     void extractHeader_loadThrowsException_propagates() throws Exception {
-        when(pdfDocumentFactory.load(pdfFile)).thenThrow(new java.io.IOException("bad PDF"));
+        when(pdfDocumentFactory.load(any(MultipartFile.class)))
+                .thenThrow(new java.io.IOException("bad PDF"));
 
-        assertThrows(java.io.IOException.class, () -> showJavascript.extractHeader(request));
+        assertThrows(java.io.IOException.class, () -> showJavascript.extractHeader(pdfFile, null));
     }
 }

app/core/src/test/java/stirling/software/SPDF/controller/api/security/GetInfoOnPDFTest.java

@@ -25,6 +25,7 @@ import org.apache.pdfbox.pdmodel.interactive.action.PDActionJavaScript;
 import org.apache.pdfbox.pdmodel.interactive.action.PDActionLaunch;
 import org.apache.pdfbox.pdmodel.interactive.action.PDActionURI;
 import org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotationLink;
+import org.jboss.resteasy.reactive.multipart.FileUpload;
 import org.junit.jupiter.api.*;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -34,16 +35,14 @@ import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
-import org.springframework.mock.web.MockMultipartFile;
-import org.springframework.web.multipart.MultipartFile;
+
+import jakarta.ws.rs.core.Response;
 
 import stirling.software.SPDF.model.api.security.PDFVerificationResult;
 import stirling.software.SPDF.service.VeraPDFService;
-import stirling.software.common.model.api.PDFFile;
+import stirling.software.common.model.MultipartFile;
 import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.testsupport.TestFileUploads;
 
 import tools.jackson.databind.JsonNode;
 import tools.jackson.databind.ObjectMapper;
@@ -68,8 +67,8 @@ class GetInfoOnPDFTest {
         objectMapper = JsonMapper.builder().build();
     }
 
-    /** Helper method to load a PDF file from test resources */
-    private MockMultipartFile loadPdfFromResources(String filename) throws IOException {
+    /** Helper method to load PDF bytes from test resources */
+    private byte[] loadPdfBytesFromResources(String filename) throws IOException {
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
         if (classLoader == null) {
             classLoader = getClass().getClassLoader();
@@ -78,9 +77,7 @@ class GetInfoOnPDFTest {
         if (classLoader != null) {
             try (InputStream resourceStream = classLoader.getResourceAsStream(filename)) {
                 if (resourceStream != null) {
-                    byte[] content = resourceStream.readAllBytes();
-                    return new MockMultipartFile(
-                            "file", filename, MediaType.APPLICATION_PDF_VALUE, content);
+                    return resourceStream.readAllBytes();
                 }
             }
         }
@@ -98,9 +95,7 @@ class GetInfoOnPDFTest {
         for (Path directory : searchDirectories) {
             Path filePath = directory.resolve(filename);
             if (Files.exists(filePath)) {
-                byte[] content = Files.readAllBytes(filePath);
-                return new MockMultipartFile(
-                        "file", filename, MediaType.APPLICATION_PDF_VALUE, content);
+                return Files.readAllBytes(filePath);
             }
         }
 
@@ -170,14 +165,17 @@ class GetInfoOnPDFTest {
         return document;
     }
 
-    /** Helper method to convert PDDocument to MockMultipartFile */
-    private MockMultipartFile documentToMultipartFile(PDDocument document, String filename)
-            throws IOException {
+    /** Helper method to serialize a PDDocument to bytes (and close it). */
+    private byte[] documentToBytes(PDDocument document) throws IOException {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         document.save(baos);
         document.close();
-        return new MockMultipartFile(
-                "file", filename, MediaType.APPLICATION_PDF_VALUE, baos.toByteArray());
+        return baos.toByteArray();
+    }
+
+    /** Helper method to build a FileUpload PDF part from raw bytes. */
+    private FileUpload pdfUpload(byte[] bytes, String filename) {
+        return TestFileUploads.of(bytes, filename, "application/pdf");
     }
 
     @Nested
@@ -187,26 +185,24 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should successfully extract info from a valid PDF")
         void testGetPdfInfo_ValidPdf() throws IOException {
-            PDDocument document = createPdfWithMetadata();
-            MockMultipartFile mockFile = documentToMultipartFile(document, "test.pdf");
+            byte[] pdfBytes = documentToBytes(createPdfWithMetadata());
+            FileUpload upload = pdfUpload(pdfBytes, "test.pdf");
 
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
-
-            try (PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes())) {
+            try (PDDocument loadedDoc = Loader.loadPDF(pdfBytes)) {
                 Mockito.when(
                                 pdfDocumentFactory.load(
                                         ArgumentMatchers.any(MultipartFile.class),
                                         ArgumentMatchers.anyBoolean()))
                         .thenReturn(loadedDoc);
 
-                ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+                Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
                 Assertions.assertNotNull(response);
-                Assertions.assertEquals(HttpStatus.OK, response.getStatusCode());
-                Assertions.assertNotNull(response.getBody());
+                Assertions.assertEquals(200, response.getStatus());
+                Assertions.assertNotNull(response.getEntity());
 
-                String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+                String jsonResponse =
+                        new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
                 JsonNode jsonNode = objectMapper.readTree(jsonResponse);
 
                 Assertions.assertTrue(jsonNode.has("Metadata"));
@@ -225,22 +221,21 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should extract basic info correctly")
         void testGetPdfInfo_BasicInfo() throws IOException {
-            PDDocument document = createSimplePdfWithText("Test content with some words");
-            MockMultipartFile mockFile = documentToMultipartFile(document, "basic.pdf");
+            byte[] pdfBytes =
+                    documentToBytes(createSimplePdfWithText("Test content with some words"));
+            FileUpload upload = pdfUpload(pdfBytes, "basic.pdf");
 
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
-
-            try (PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes())) {
+            try (PDDocument loadedDoc = Loader.loadPDF(pdfBytes)) {
                 Mockito.when(
                                 pdfDocumentFactory.load(
                                         ArgumentMatchers.any(MultipartFile.class),
                                         ArgumentMatchers.anyBoolean()))
                         .thenReturn(loadedDoc);
 
-                ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+                Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
-                String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+                String jsonResponse =
+                        new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
                 JsonNode jsonNode = objectMapper.readTree(jsonResponse);
                 JsonNode basicInfo = jsonNode.get("BasicInfo");
 
@@ -262,20 +257,20 @@ class GetInfoOnPDFTest {
             document.addPage(new PDPage(PDRectangle.A4));
             document.addPage(new PDPage(PDRectangle.LETTER));
 
-            MockMultipartFile mockFile = documentToMultipartFile(document, "multipage.pdf");
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
+            byte[] pdfBytes = documentToBytes(document);
+            FileUpload upload = pdfUpload(pdfBytes, "multipage.pdf");
 
-            try (PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes())) {
+            try (PDDocument loadedDoc = Loader.loadPDF(pdfBytes)) {
                 Mockito.when(
                                 pdfDocumentFactory.load(
                                         ArgumentMatchers.any(MultipartFile.class),
                                         ArgumentMatchers.anyBoolean()))
                         .thenReturn(loadedDoc);
 
-                ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+                Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
-                String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+                String jsonResponse =
+                        new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
                 JsonNode jsonNode = objectMapper.readTree(jsonResponse);
 
                 Assertions.assertEquals(
@@ -297,22 +292,19 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should extract all metadata fields")
         void testExtractMetadata_AllFields() throws IOException {
-            PDDocument document = createPdfWithMetadata();
-            MockMultipartFile mockFile = documentToMultipartFile(document, "metadata.pdf");
+            byte[] pdfBytes = documentToBytes(createPdfWithMetadata());
+            FileUpload upload = pdfUpload(pdfBytes, "metadata.pdf");
 
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
-
-            PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes());
+            PDDocument loadedDoc = Loader.loadPDF(pdfBytes);
             Mockito.when(
                             pdfDocumentFactory.load(
                                     ArgumentMatchers.any(MultipartFile.class),
                                     ArgumentMatchers.anyBoolean()))
                     .thenReturn(loadedDoc);
 
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+            Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
             JsonNode metadata = jsonNode.get("Metadata");
 
@@ -331,25 +323,22 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should handle PDF with missing metadata")
         void testExtractMetadata_MissingFields() throws IOException {
-            PDDocument document = createSimplePdfWithText("No metadata");
-            MockMultipartFile mockFile = documentToMultipartFile(document, "no-metadata.pdf");
+            byte[] pdfBytes = documentToBytes(createSimplePdfWithText("No metadata"));
+            FileUpload upload = pdfUpload(pdfBytes, "no-metadata.pdf");
 
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
-
-            PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes());
+            PDDocument loadedDoc = Loader.loadPDF(pdfBytes);
             Mockito.when(
                             pdfDocumentFactory.load(
                                     ArgumentMatchers.any(MultipartFile.class),
                                     ArgumentMatchers.anyBoolean()))
                     .thenReturn(loadedDoc);
 
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+            Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
             Assertions.assertNotNull(response);
-            Assertions.assertEquals(HttpStatus.OK, response.getStatusCode());
+            Assertions.assertEquals(200, response.getStatus());
 
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
             JsonNode metadata = jsonNode.get("Metadata");
 
@@ -366,22 +355,19 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should detect unencrypted PDF")
         void testEncryption_UnencryptedPdf() throws IOException {
-            PDDocument document = createSimplePdfWithText("Not encrypted");
-            MockMultipartFile mockFile = documentToMultipartFile(document, "unencrypted.pdf");
+            byte[] pdfBytes = documentToBytes(createSimplePdfWithText("Not encrypted"));
+            FileUpload upload = pdfUpload(pdfBytes, "unencrypted.pdf");
 
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
-
-            PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes());
+            PDDocument loadedDoc = Loader.loadPDF(pdfBytes);
             Mockito.when(
                             pdfDocumentFactory.load(
                                     ArgumentMatchers.any(MultipartFile.class),
                                     ArgumentMatchers.anyBoolean()))
                     .thenReturn(loadedDoc);
 
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+            Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
             JsonNode encryption = jsonNode.get("Encryption");
 
@@ -393,22 +379,19 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should extract all permissions")
         void testPermissions_AllPermissions() throws IOException {
-            PDDocument document = createSimplePdfWithText("Test permissions");
-            MockMultipartFile mockFile = documentToMultipartFile(document, "permissions.pdf");
+            byte[] pdfBytes = documentToBytes(createSimplePdfWithText("Test permissions"));
+            FileUpload upload = pdfUpload(pdfBytes, "permissions.pdf");
 
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
-
-            PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes());
+            PDDocument loadedDoc = Loader.loadPDF(pdfBytes);
             Mockito.when(
                             pdfDocumentFactory.load(
                                     ArgumentMatchers.any(MultipartFile.class),
                                     ArgumentMatchers.anyBoolean()))
                     .thenReturn(loadedDoc);
 
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+            Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
             JsonNode permissions = jsonNode.get("Permissions");
 
@@ -429,22 +412,21 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should extract form fields section from PDF")
         void testFormFields_Structure() throws IOException {
-            PDDocument document = createSimplePdfWithText("Document to test form fields section");
-            MockMultipartFile mockFile = documentToMultipartFile(document, "test-forms.pdf");
+            byte[] pdfBytes =
+                    documentToBytes(
+                            createSimplePdfWithText("Document to test form fields section"));
+            FileUpload upload = pdfUpload(pdfBytes, "test-forms.pdf");
 
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
-
-            PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes());
+            PDDocument loadedDoc = Loader.loadPDF(pdfBytes);
             Mockito.when(
                             pdfDocumentFactory.load(
                                     ArgumentMatchers.any(MultipartFile.class),
                                     ArgumentMatchers.anyBoolean()))
                     .thenReturn(loadedDoc);
 
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+            Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
 
             Assertions.assertTrue(jsonNode.has("FormFields"));
@@ -457,22 +439,19 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should handle PDF without form fields")
         void testFormFields_NoFields() throws IOException {
-            PDDocument document = createSimplePdfWithText("No form fields");
-            MockMultipartFile mockFile = documentToMultipartFile(document, "no-forms.pdf");
+            byte[] pdfBytes = documentToBytes(createSimplePdfWithText("No form fields"));
+            FileUpload upload = pdfUpload(pdfBytes, "no-forms.pdf");
 
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
-
-            PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes());
+            PDDocument loadedDoc = Loader.loadPDF(pdfBytes);
             Mockito.when(
                             pdfDocumentFactory.load(
                                     ArgumentMatchers.any(MultipartFile.class),
                                     ArgumentMatchers.anyBoolean()))
                     .thenReturn(loadedDoc);
 
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+            Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
             JsonNode formFields = jsonNode.get("FormFields");
 
@@ -493,20 +472,19 @@ class GetInfoOnPDFTest {
             document.addPage(new PDPage(PDRectangle.A4));
             document.addPage(new PDPage(PDRectangle.LETTER));
 
-            MockMultipartFile mockFile = documentToMultipartFile(document, "dimensions.pdf");
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
+            byte[] pdfBytes = documentToBytes(document);
+            FileUpload upload = pdfUpload(pdfBytes, "dimensions.pdf");
 
-            PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes());
+            PDDocument loadedDoc = Loader.loadPDF(pdfBytes);
             Mockito.when(
                             pdfDocumentFactory.load(
                                     ArgumentMatchers.any(MultipartFile.class),
                                     ArgumentMatchers.anyBoolean()))
                     .thenReturn(loadedDoc);
 
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+            Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
             JsonNode perPageInfo = jsonNode.get("PerPageInfo");
 
@@ -529,20 +507,19 @@ class GetInfoOnPDFTest {
             page.setRotation(90);
             document.addPage(page);
 
-            MockMultipartFile mockFile = documentToMultipartFile(document, "rotated.pdf");
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
+            byte[] pdfBytes = documentToBytes(document);
+            FileUpload upload = pdfUpload(pdfBytes, "rotated.pdf");
 
-            PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes());
+            PDDocument loadedDoc = Loader.loadPDF(pdfBytes);
             Mockito.when(
                             pdfDocumentFactory.load(
                                     ArgumentMatchers.any(MultipartFile.class),
                                     ArgumentMatchers.anyBoolean()))
                     .thenReturn(loadedDoc);
 
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+            Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
             JsonNode page1 = jsonNode.get("PerPageInfo").get("Page 1");
 
@@ -559,14 +536,10 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should reject null file")
         void testValidation_NullFile() throws IOException {
-            PDFFile request = new PDFFile();
-            request.setFileInput(null);
+            Response response = getInfoOnPDF.getPdfInfo(null, null);
 
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
-
-            Assertions.assertEquals(
-                    HttpStatus.OK, response.getStatusCode()); // Returns error JSON with 200
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            Assertions.assertEquals(200, response.getStatus()); // Returns error JSON with 200
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
 
             Assertions.assertTrue(jsonNode.has("error"));
@@ -577,16 +550,11 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should reject empty file")
         void testValidation_EmptyFile() throws IOException {
-            MockMultipartFile emptyFile =
-                    new MockMultipartFile(
-                            "file", "empty.pdf", MediaType.APPLICATION_PDF_VALUE, new byte[0]);
+            FileUpload emptyFile = pdfUpload(new byte[0], "empty.pdf");
 
-            PDFFile request = new PDFFile();
-            request.setFileInput(emptyFile);
+            Response response = getInfoOnPDF.getPdfInfo(emptyFile, null);
 
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
-
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
 
             Assertions.assertTrue(jsonNode.has("error"));
@@ -595,54 +563,15 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should reject file that exceeds max size")
         void testValidation_TooLargeFile() throws IOException {
-            MultipartFile largeFile =
-                    new MultipartFile() {
-                        @Override
-                        public String getName() {
-                            return "file";
-                        }
+            // Report 101 MB without allocating memory: a FileUpload whose size() exceeds the limit.
+            FileUpload largeFile = Mockito.mock(FileUpload.class);
+            Mockito.lenient().when(largeFile.fileName()).thenReturn("large.pdf");
+            Mockito.lenient().when(largeFile.contentType()).thenReturn("application/pdf");
+            Mockito.lenient().when(largeFile.size()).thenReturn(101L * 1024L * 1024L);
 
-                        @Override
-                        public String getOriginalFilename() {
-                            return "large.pdf";
-                        }
+            Response response = getInfoOnPDF.getPdfInfo(largeFile, null);
 
-                        @Override
-                        public String getContentType() {
-                            return MediaType.APPLICATION_PDF_VALUE;
-                        }
-
-                        @Override
-                        public boolean isEmpty() {
-                            return false;
-                        }
-
-                        @Override
-                        public long getSize() {
-                            // Report 101 MB without allocating memory
-                            return 101L * 1024L * 1024L;
-                        }
-
-                        @Override
-                        public byte[] getBytes() {
-                            return new byte[0];
-                        }
-
-                        @Override
-                        public java.io.InputStream getInputStream() {
-                            return java.io.InputStream.nullInputStream();
-                        }
-
-                        @Override
-                        public void transferTo(java.io.File dest) throws IllegalStateException {}
-                    };
-
-            PDFFile request = new PDFFile();
-            request.setFileInput(largeFile);
-
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
-
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
 
             Assertions.assertTrue(jsonNode.has("error"));
@@ -684,24 +613,23 @@ class GetInfoOnPDFTest {
         @DisplayName("Should process example.pdf from test resources")
         void testRealPdf_Example() {
             try {
-                MockMultipartFile mockFile = loadPdfFromResources("example.pdf");
+                byte[] pdfBytes = loadPdfBytesFromResources("example.pdf");
+                FileUpload upload = pdfUpload(pdfBytes, "example.pdf");
 
-                PDFFile request = new PDFFile();
-                request.setFileInput(mockFile);
-
-                try (PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes())) {
+                try (PDDocument loadedDoc = Loader.loadPDF(pdfBytes)) {
                     Mockito.when(
                                     pdfDocumentFactory.load(
                                             ArgumentMatchers.any(MultipartFile.class),
                                             ArgumentMatchers.anyBoolean()))
                             .thenReturn(loadedDoc);
 
-                    ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+                    Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
                     Assertions.assertNotNull(response);
-                    Assertions.assertEquals(HttpStatus.OK, response.getStatusCode());
+                    Assertions.assertEquals(200, response.getStatus());
 
-                    String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+                    String jsonResponse =
+                            new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
                     JsonNode jsonNode = objectMapper.readTree(jsonResponse);
 
                     Assertions.assertFalse(
@@ -721,22 +649,21 @@ class GetInfoOnPDFTest {
         @DisplayName("Should process tables.pdf")
         void testRealPdf_Tables() {
             try {
-                MockMultipartFile mockFile = loadPdfFromResources("tables.pdf");
+                byte[] pdfBytes = loadPdfBytesFromResources("tables.pdf");
+                FileUpload upload = pdfUpload(pdfBytes, "tables.pdf");
 
-                PDFFile request = new PDFFile();
-                request.setFileInput(mockFile);
-
-                try (PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes())) {
+                try (PDDocument loadedDoc = Loader.loadPDF(pdfBytes)) {
                     Mockito.when(
                                     pdfDocumentFactory.load(
                                             ArgumentMatchers.any(MultipartFile.class),
                                             ArgumentMatchers.anyBoolean()))
                             .thenReturn(loadedDoc);
 
-                    ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+                    Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
                     Assertions.assertNotNull(response);
-                    String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+                    String jsonResponse =
+                            new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
                     JsonNode jsonNode = objectMapper.readTree(jsonResponse);
 
                     Assertions.assertFalse(jsonNode.has("error"));
@@ -756,13 +683,10 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should extract compliance info using VeraPDF")
         void testCompliance_PdfA() throws Exception {
-            PDDocument document = createSimplePdfWithText("Test PDF/A");
-            MockMultipartFile mockFile = documentToMultipartFile(document, "pdfa.pdf");
+            byte[] pdfBytes = documentToBytes(createSimplePdfWithText("Test PDF/A"));
+            FileUpload upload = pdfUpload(pdfBytes, "pdfa.pdf");
 
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
-
-            PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes());
+            PDDocument loadedDoc = Loader.loadPDF(pdfBytes);
             Mockito.when(
                             pdfDocumentFactory.load(
                                     ArgumentMatchers.any(MultipartFile.class),
@@ -777,9 +701,9 @@ class GetInfoOnPDFTest {
             Mockito.when(veraPDFService.validatePDF(ArgumentMatchers.any(InputStream.class)))
                     .thenReturn(List.of(result));
 
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+            Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
             JsonNode compliancy = jsonNode.get("Compliancy");
 
@@ -797,22 +721,20 @@ class GetInfoOnPDFTest {
         @Test
         @DisplayName("Should extract image statistics from PDF")
         void testImageStatistics() throws IOException {
-            PDDocument document = createSimplePdfWithText("Document for image statistics");
-            MockMultipartFile mockFile = documentToMultipartFile(document, "no-images.pdf");
+            byte[] pdfBytes =
+                    documentToBytes(createSimplePdfWithText("Document for image statistics"));
+            FileUpload upload = pdfUpload(pdfBytes, "no-images.pdf");
 
-            PDFFile request = new PDFFile();
-            request.setFileInput(mockFile);
-
-            PDDocument loadedDoc = Loader.loadPDF(mockFile.getBytes());
+            PDDocument loadedDoc = Loader.loadPDF(pdfBytes);
             Mockito.when(
                             pdfDocumentFactory.load(
                                     ArgumentMatchers.any(MultipartFile.class),
                                     ArgumentMatchers.anyBoolean()))
                     .thenReturn(loadedDoc);
 
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+            Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
             JsonNode basicInfo = jsonNode.get("BasicInfo");
 
@@ -912,12 +834,10 @@ class GetInfoOnPDFTest {
                                     ArgumentMatchers.anyBoolean()))
                     .thenReturn(Loader.loadPDF(bytes));
 
-            PDFFile request = new PDFFile();
-            request.setFileInput(
-                    new MockMultipartFile("file", "test.pdf", "application/pdf", bytes));
-            ResponseEntity<byte[]> response = getInfoOnPDF.getPdfInfo(request);
+            FileUpload upload = pdfUpload(bytes, "test.pdf");
+            Response response = getInfoOnPDF.getPdfInfo(upload, null);
 
-            String jsonResponse = new String(response.getBody(), StandardCharsets.UTF_8);
+            String jsonResponse = new String((byte[]) response.getEntity(), StandardCharsets.UTF_8);
             JsonNode jsonNode = objectMapper.readTree(jsonResponse);
             boolean actual = jsonNode.get("Compliancy").get("IsPDF/SECCompliant").asBoolean();
 

app/core/src/test/java/stirling/software/SPDF/model/api/converters/ConvertPDFToMarkdownTest.java

@@ -1,51 +1,41 @@
 package stirling.software.SPDF.model.api.converters;
 
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
 
 import java.io.File;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
 
+import org.jboss.resteasy.reactive.multipart.FileUpload;
 import org.junit.jupiter.api.Test;
 import org.mockito.MockedConstruction;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
-import org.springframework.core.io.ByteArrayResource;
-import org.springframework.core.io.Resource;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.mock.web.MockMultipartFile;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
-import org.springframework.web.bind.annotation.ExceptionHandler;
-import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+import jakarta.ws.rs.core.Response;
 
 import stirling.software.common.pdf.PdfMarkdownConverter;
+import stirling.software.common.testsupport.TestFileUploads;
 import stirling.software.common.util.TempFile;
 import stirling.software.jpdfium.PdfDocument;
 
+/**
+ * MIGRATION (Spring -> Quarkus): {@code ConvertPDFToMarkdown} is a JAX-RS resource returning {@link
+ * Response}; the handler binds a RESTEasy Reactive {@code FileUpload} (stubbed via {@link
+ * TestFileUploads}) and the {@code TempFile} now takes a {@code TempFileManager} (intercepted by
+ * the existing {@code MockedConstruction<TempFile>}, so a {@code null} manager is fine).
+ *
+ * <p>The former MockMvc + {@code @RestControllerAdvice} setup is dropped: the success path is read
+ * straight off {@code Response} (status / content-type / body bytes), and the error path - which
+ * the controller propagates rather than mapping to 500 itself - is asserted with {@code
+ * assertThrows}.
+ */
 class ConvertPDFToMarkdownTest {
 
-    private MockMvc mockMvc() {
-        return MockMvcBuilders.standaloneSetup(new ConvertPDFToMarkdown(null))
-                .setControllerAdvice(new GlobalErrorHandler())
-                .build();
-    }
-
-    @RestControllerAdvice
-    static class GlobalErrorHandler {
-        @ExceptionHandler(Exception.class)
-        ResponseEntity<Resource> handle(Exception ex) {
-            String message = ex.getMessage();
-            byte[] body = message != null ? message.getBytes(StandardCharsets.UTF_8) : new byte[0];
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
-                    .body(new ByteArrayResource(body));
-        }
-    }
-
     @Test
     void pdfToMarkdownReturnsMarkdownBytes() throws Exception {
         byte[] md = "# heading\n\ncontent\n".getBytes(StandardCharsets.UTF_8);
@@ -70,15 +60,15 @@ class ConvertPDFToMarkdownTest {
             PdfDocument mockDoc = Mockito.mock(PdfDocument.class);
             docStatic.when(() -> PdfDocument.open(any(Path.class))).thenReturn(mockDoc);
 
-            MockMultipartFile file =
-                    new MockMultipartFile(
-                            "fileInput", "input.pdf", "application/pdf", new byte[] {1, 2, 3});
+            FileUpload file =
+                    TestFileUploads.of(new byte[] {1, 2, 3}, "input.pdf", "application/pdf");
 
-            mockMvc()
-                    .perform(multipart("/api/v1/convert/pdf/markdown").file(file))
-                    .andExpect(status().isOk())
-                    .andExpect(header().string("Content-Type", "text/markdown"))
-                    .andExpect(content().bytes(md));
+            ConvertPDFToMarkdown controller = new ConvertPDFToMarkdown(null);
+            Response resp = controller.processPdfToMarkdown(file, null);
+
+            assertEquals(200, resp.getStatus());
+            assertEquals("text/markdown", resp.getMediaType().toString());
+            assertArrayEquals(md, (byte[]) resp.getEntity());
         }
     }
 
@@ -105,13 +95,17 @@ class ConvertPDFToMarkdownTest {
             PdfDocument mockDoc = Mockito.mock(PdfDocument.class);
             docStatic.when(() -> PdfDocument.open(any(Path.class))).thenReturn(mockDoc);
 
-            MockMultipartFile file =
-                    new MockMultipartFile(
-                            "fileInput", "x.pdf", "application/pdf", new byte[] {0x01});
+            FileUpload file = TestFileUploads.of(new byte[] {0x01}, "x.pdf", "application/pdf");
 
-            mockMvc()
-                    .perform(multipart("/api/v1/convert/pdf/markdown").file(file))
-                    .andExpect(status().isInternalServerError());
+            ConvertPDFToMarkdown controller = new ConvertPDFToMarkdown(null);
+
+            // The converter failure propagates out of the handler (no controller-level mapping to
+            // 500); JAX-RS would surface it as a 500 at the HTTP boundary.
+            RuntimeException ex =
+                    assertThrows(
+                            RuntimeException.class,
+                            () -> controller.processPdfToMarkdown(file, null));
+            assertEquals("boom", ex.getMessage());
         }
     }
 }

app/proprietary/src/test/java/stirling/software/common/testsupport/TestFileUploads.java

@@ -0,0 +1,52 @@
+package stirling.software.common.testsupport;
+
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.jboss.resteasy.reactive.multipart.FileUpload;
+
+/**
+ * Builds RESTEasy Reactive {@link FileUpload} stubs for unit tests. The migrated controllers bind
+ * {@code @RestForm FileUpload} and wrap it via {@code FileUploadMultipartFile.of(...)}, which reads
+ * {@code uploadedFile()}/{@code fileName()}/{@code size()}. This backs the mock with a real temp
+ * file so those reads work whether or not the collaborator (e.g. {@code CustomPDFDocumentFactory})
+ * is itself mocked. All stubs are lenient so a test that never reaches a given accessor does not
+ * trip strict-stubbing.
+ *
+ * <p>Duplicated per-module (also in {@code :stirling-pdf}) because module test source sets do not
+ * share sources - same approach already used for {@code ReflectionTestUtils}.
+ */
+public final class TestFileUploads {
+
+    private TestFileUploads() {}
+
+    public static FileUpload of(byte[] content, String fileName, String contentType) {
+        try {
+            byte[] bytes = content == null ? new byte[0] : content;
+            String suffix = fileName == null ? "file" : fileName.replaceAll("[^a-zA-Z0-9._-]", "_");
+            Path tmp = Files.createTempFile("test-upload-", "-" + suffix);
+            tmp.toFile().deleteOnExit();
+            Files.write(tmp, bytes);
+
+            FileUpload upload = mock(FileUpload.class);
+            lenient().when(upload.uploadedFile()).thenReturn(tmp);
+            lenient().when(upload.filePath()).thenReturn(tmp);
+            lenient().when(upload.fileName()).thenReturn(fileName);
+            lenient().when(upload.contentType()).thenReturn(contentType);
+            lenient().when(upload.size()).thenReturn((long) bytes.length);
+            return upload;
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+
+    /** Convenience for a PDF part named {@code test.pdf}. */
+    public static FileUpload pdf(byte[] content) {
+        return of(content, "test.pdf", "application/pdf");
+    }
+}

app/proprietary/src/test/java/stirling/software/proprietary/controller/api/PdfCommentAgentControllerTest.java

@@ -1,136 +1,122 @@
 package stirling.software.proprietary.controller.api;
 
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
+import org.jboss.resteasy.reactive.multipart.FileUpload;
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.MediaType;
-import org.springframework.mock.web.MockMultipartFile;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
-import org.springframework.web.multipart.MultipartFile;
-import org.springframework.web.server.ResponseStatusException;
-import org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver;
-import org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver;
 
+import jakarta.ws.rs.WebApplicationException;
+import jakarta.ws.rs.core.Response;
+
+import stirling.software.common.model.MultipartFile;
+import stirling.software.common.testsupport.TestFileUploads;
 import stirling.software.proprietary.service.PdfCommentAgentOrchestrator;
 import stirling.software.proprietary.service.PdfCommentAgentOrchestrator.AnnotatedPdf;
 
 import tools.jackson.databind.json.JsonMapper;
 
 /**
- * Controller tests for {@link PdfCommentAgentController}. The orchestrator is mocked so the test
- * never hits the engine or real filesystem.
+ * MIGRATION (Spring -> Quarkus): {@code PdfCommentAgentController} is a JAX-RS resource taking a
+ * RESTEasy Reactive {@code FileUpload} + form {@code prompt} and returning {@link Response}. Tests
+ * call the handler directly with a {@link TestFileUploads} stub for the upload.
+ *
+ * <p>The orchestrator is mocked so the test never hits the engine or real filesystem. Validation
+ * errors are now signalled by {@code WebApplicationException} (was Spring {@code
+ * ResponseStatusException}); the controller lets them propagate, so the error-path tests assert the
+ * thrown status rather than a MockMvc {@code status()} matcher. The former "missing required form
+ * param" tests (previously enforced by Spring's {@code DefaultHandlerExceptionResolver}) are kept
+ * as direct-call equivalents: a missing file arrives as {@code null} and the controller fails fast
+ * before reaching the orchestrator; a missing prompt is rejected by the orchestrator with 400.
  */
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
 @ExtendWith(MockitoExtension.class)
 class PdfCommentAgentControllerTest {
 
     @Mock private PdfCommentAgentOrchestrator orchestrator;
 
-    private MockMvc mockMvc;
+    private PdfCommentAgentController controller;
 
     @BeforeEach
     void setUp() {
-        PdfCommentAgentController controller =
-                new PdfCommentAgentController(orchestrator, JsonMapper.builder().build());
-        mockMvc =
-                MockMvcBuilders.standaloneSetup(controller)
-                        // standaloneSetup's defaults don't handle ResponseStatusException; wire up
-                        // both the ResponseStatusException resolver (for orchestrator 400s) and
-                        // DefaultHandlerExceptionResolver (so missing @RequestParam still 400s).
-                        .setHandlerExceptionResolvers(
-                                new ResponseStatusExceptionResolver(),
-                                new DefaultHandlerExceptionResolver())
-                        .build();
+        controller = new PdfCommentAgentController();
+        controller.orchestrator = orchestrator;
+        controller.objectMapper = JsonMapper.builder().build();
     }
 
     @Test
     void acceptsValidPdfAndReturnsAnnotatedBytes() throws Exception {
-        MockMultipartFile pdfFile =
-                new MockMultipartFile(
-                        "fileInput",
-                        "input.pdf",
-                        MediaType.APPLICATION_PDF_VALUE,
-                        "%PDF-1.4\n%%EOF".getBytes());
+        FileUpload pdfFile =
+                TestFileUploads.of("%PDF-1.4\n%%EOF".getBytes(), "input.pdf", "application/pdf");
 
         byte[] annotatedBytes = "%PDF-1.4\n<annotated>\n%%EOF".getBytes();
         AnnotatedPdf stub = new AnnotatedPdf(annotatedBytes, "input-commented.pdf", 2, 2, "ok");
         when(orchestrator.applyComments(any(MultipartFile.class), eq("flag dates")))
                 .thenReturn(stub);
 
-        mockMvc.perform(
-                        multipart("/api/v1/ai/tools/pdf-comment-agent")
-                                .file(pdfFile)
-                                .param("prompt", "flag dates"))
-                .andExpect(status().isOk())
-                .andExpect(content().contentType(MediaType.APPLICATION_PDF))
-                .andExpect(
-                        header().string(
-                                        "Content-Disposition",
-                                        org.hamcrest.Matchers.containsString(
-                                                "input-commented.pdf")))
-                .andExpect(content().bytes(annotatedBytes));
+        Response resp = controller.pdfCommentAgent(pdfFile, "flag dates");
+
+        assertEquals(200, resp.getStatus());
+        assertEquals("application/pdf", resp.getMediaType().toString());
+        assertTrue(resp.getHeaderString("Content-Disposition").contains("input-commented.pdf"));
+        assertArrayEquals(annotatedBytes, (byte[]) resp.getEntity());
 
         verify(orchestrator).applyComments(any(MultipartFile.class), eq("flag dates"));
     }
 
     @Test
     void propagatesOrchestratorBadRequestForNonPdfUpload() throws Exception {
-        // The controller delegates validation to the orchestrator; a ResponseStatusException
-        // thrown by the orchestrator should propagate to Spring as a 400.
-        MockMultipartFile notPdf =
-                new MockMultipartFile(
-                        "fileInput", "input.txt", MediaType.TEXT_PLAIN_VALUE, "hello".getBytes());
+        // The controller delegates validation to the orchestrator; a WebApplicationException
+        // thrown by the orchestrator should propagate as a 400.
+        FileUpload notPdf = TestFileUploads.of("hello".getBytes(), "input.txt", "text/plain");
         when(orchestrator.applyComments(any(MultipartFile.class), eq("whatever")))
                 .thenThrow(
-                        new ResponseStatusException(
-                                HttpStatus.BAD_REQUEST,
-                                "Only application/pdf uploads are supported"));
+                        new WebApplicationException(
+                                "Only application/pdf uploads are supported",
+                                Response.Status.BAD_REQUEST));
 
-        mockMvc.perform(
-                        multipart("/api/v1/ai/tools/pdf-comment-agent")
-                                .file(notPdf)
-                                .param("prompt", "whatever"))
-                .andExpect(status().isBadRequest());
+        WebApplicationException ex =
+                assertThrows(
+                        WebApplicationException.class,
+                        () -> controller.pdfCommentAgent(notPdf, "whatever"));
+        assertEquals(400, ex.getResponse().getStatus());
 
         verify(orchestrator).applyComments(any(MultipartFile.class), eq("whatever"));
     }
 
     @Test
     void rejectsMissingFileInput() throws Exception {
-        mockMvc.perform(multipart("/api/v1/ai/tools/pdf-comment-agent").param("prompt", "test"))
-                .andExpect(status().is4xxClientError());
+        // A missing @RestForm FileUpload binds as null; the controller dereferences it before
+        // reaching the orchestrator, so it fails fast and never invokes applyComments.
+        assertThrows(NullPointerException.class, () -> controller.pdfCommentAgent(null, "test"));
 
-        verify(orchestrator, never()).applyComments(any(), anyString());
+        verify(orchestrator, never()).applyComments(any(), any());
     }
 
     @Test
     void rejectsMissingPromptParameter() throws Exception {
-        MockMultipartFile pdfFile =
-                new MockMultipartFile(
-                        "fileInput",
-                        "input.pdf",
-                        MediaType.APPLICATION_PDF_VALUE,
-                        "%PDF-1.4\n%%EOF".getBytes());
+        // Prompt validation now lives in the orchestrator (throws 400 "Prompt is required").
+        FileUpload pdfFile =
+                TestFileUploads.of("%PDF-1.4\n%%EOF".getBytes(), "input.pdf", "application/pdf");
+        when(orchestrator.applyComments(any(MultipartFile.class), eq(null)))
+                .thenThrow(
+                        new WebApplicationException(
+                                "Prompt is required", Response.Status.BAD_REQUEST));
 
-        mockMvc.perform(multipart("/api/v1/ai/tools/pdf-comment-agent").file(pdfFile))
-                .andExpect(status().is4xxClientError());
-
-        verify(orchestrator, never()).applyComments(any(), anyString());
+        WebApplicationException ex =
+                assertThrows(
+                        WebApplicationException.class,
+                        () -> controller.pdfCommentAgent(pdfFile, null));
+        assertEquals(400, ex.getResponse().getStatus());
     }
 }

app/proprietary/src/test/java/stirling/software/proprietary/controller/api/SignatureControllerTest.java

@@ -1,39 +1,44 @@
 package stirling.software.proprietary.controller.api;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import java.util.Map;
 
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.http.MediaType;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
 
+import jakarta.ws.rs.core.Response;
+
+import stirling.software.proprietary.model.api.signature.SavedSignatureRequest;
 import stirling.software.proprietary.security.service.UserService;
 import stirling.software.proprietary.service.SignatureService;
 
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
+/**
+ * MIGRATION (Spring -> Quarkus): {@code SignatureController} is now a JAX-RS resource returning
+ * {@link Response}. The handlers RETURN their status codes (forbidden / no-content) rather than
+ * letting Spring map a thrown exception, so the former MockMvc {@code status()} matchers become
+ * {@code resp.getStatus()} assertions. JSON request bodies are passed as the typed DTO / {@code
+ * Map<String,String>} the endpoints declare instead of raw JSON strings.
+ */
 @ExtendWith(MockitoExtension.class)
 class SignatureControllerTest {
 
     @Mock private SignatureService signatureService;
     @Mock private UserService userService;
 
-    private MockMvc mockMvc;
+    private SignatureController controller;
 
     @BeforeEach
     void setUp() {
-        SignatureController controller = new SignatureController(signatureService, userService);
-        mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
+        controller = new SignatureController(signatureService, userService);
     }
 
     @Test
@@ -41,19 +46,14 @@ class SignatureControllerTest {
         when(userService.getCurrentUsername()).thenReturn("user1");
         when(userService.isCurrentUserAdmin()).thenReturn(false);
 
-        mockMvc.perform(
-                        post("/api/v1/proprietary/signatures")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(
-                                        """
-                                        {
-                                          "id": "sig1",
-                                          "scope": "shared",
-                                          "dataUrl": "data:image/png;base64,AAAA"
-                                        }
-                                        """))
-                .andExpect(status().isForbidden());
+        SavedSignatureRequest request = new SavedSignatureRequest();
+        request.setId("sig1");
+        request.setScope("shared");
+        request.setDataUrl("data:image/png;base64,AAAA");
 
+        Response resp = controller.saveSignature(request);
+
+        assertEquals(Response.Status.FORBIDDEN.getStatusCode(), resp.getStatus());
         verify(signatureService, never()).saveSignature(any(), any());
     }
 
@@ -63,12 +63,9 @@ class SignatureControllerTest {
         when(userService.isCurrentUserAdmin()).thenReturn(false);
         when(signatureService.isSharedSignature("sig123")).thenReturn(true);
 
-        mockMvc.perform(
-                        post("/api/v1/proprietary/signatures/sig123/label")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content("{\"label\":\"new label\"}"))
-                .andExpect(status().isForbidden());
+        Response resp = controller.updateSignatureLabel("sig123", Map.of("label", "new label"));
 
+        assertEquals(Response.Status.FORBIDDEN.getStatusCode(), resp.getStatus());
         verify(signatureService, never()).updateSignatureLabel(any(), any(), any());
     }
 
@@ -78,12 +75,9 @@ class SignatureControllerTest {
         when(userService.isCurrentUserAdmin()).thenReturn(false);
         when(signatureService.isSharedSignature("sig123")).thenReturn(false);
 
-        mockMvc.perform(
-                        post("/api/v1/proprietary/signatures/sig123/label")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content("{\"label\":\"new label\"}"))
-                .andExpect(status().isNoContent());
+        Response resp = controller.updateSignatureLabel("sig123", Map.of("label", "new label"));
 
+        assertEquals(Response.Status.NO_CONTENT.getStatusCode(), resp.getStatus());
         verify(signatureService).updateSignatureLabel(eq("user1"), eq("sig123"), eq("new label"));
     }
 }

app/proprietary/src/test/java/stirling/software/proprietary/mcp/McpConditionalTest.java

@@ -2,21 +2,20 @@ package stirling.software.proprietary.mcp;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import java.util.Arrays;
+import java.io.IOException;
+import java.io.InputStream;
 
-import org.junit.jupiter.api.Disabled;
+import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.ClassInfo;
+import org.jboss.jandex.DotName;
+import org.jboss.jandex.Index;
+import org.jboss.jandex.Indexer;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-import org.springframework.context.annotation.Profile;
 
-import stirling.software.proprietary.mcp.catalog.McpToolCatalog;
-import stirling.software.proprietary.mcp.engine.EngineCapabilityClient;
-import stirling.software.proprietary.mcp.security.McpSecurityConfig;
 import stirling.software.proprietary.mcp.tools.DescribeOperationTool;
-import stirling.software.proprietary.mcp.tools.McpOperationExecutor;
 import stirling.software.proprietary.mcp.tools.StirlingAiTool;
 import stirling.software.proprietary.mcp.tools.StirlingConvertTool;
 import stirling.software.proprietary.mcp.tools.StirlingDownloadTool;
@@ -25,77 +24,86 @@ import stirling.software.proprietary.mcp.tools.StirlingPagesTool;
 import stirling.software.proprietary.mcp.tools.StirlingSecurityTool;
 import stirling.software.proprietary.mcp.tools.StirlingUploadTool;
 
-/** Verifies MCP beans are gated behind {@code @ConditionalOnProperty(name="mcp.enabled")}. */
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
+/**
+ * Verifies MCP beans are gated behind the runtime property {@code mcp.enabled=true}.
+ *
+ * <p>MIGRATION (Spring -&gt; Quarkus): gating moved from Spring {@code @ConditionalOnProperty} to
+ * Quarkus {@code @io.quarkus.arc.lookup.LookupIfProperty}, and the category tools are now
+ * individually-gated CDI beans (they were previously plain {@code @Component}s wired only into the
+ * gated controller). The annotation is read from bytecode via Jandex rather than reflection because
+ * Arc lookup annotations are not guaranteed to be runtime-retained.
+ *
+ * <p>Two assertions from the Spring-era test were intentionally not carried over: that {@code
+ * McpSecurityConfig} itself carries the gate, and that no MCP bean is profile-restricted. The MCP
+ * security wiring is dormant pending a Quarkus re-implementation (see the {@code McpSecurityConfig}
+ * "Migration required" TODOs), and some MCP beans now legitimately use {@code @IfBuildProfile}.
+ * This test guards the gating that exists today.
+ */
 class McpConditionalTest {
 
+    private static final DotName LOOKUP_IF_PROPERTY =
+            DotName.createSimple("io.quarkus.arc.lookup.LookupIfProperty");
+
+    private static final Class<?>[] GATED_BEANS = {
+        McpServerController.class,
+        DescribeOperationTool.class,
+        StirlingConvertTool.class,
+        StirlingPagesTool.class,
+        StirlingMiscTool.class,
+        StirlingSecurityTool.class,
+        StirlingAiTool.class,
+        StirlingUploadTool.class,
+        StirlingDownloadTool.class
+    };
+
+    private static Index index;
+
+    @BeforeAll
+    static void indexBeans() throws IOException {
+        Indexer indexer = new Indexer();
+        for (Class<?> bean : GATED_BEANS) {
+            String resource = bean.getName().replace('.', '/') + ".class";
+            try (InputStream in = bean.getClassLoader().getResourceAsStream(resource)) {
+                assertNotNull(in, "class bytes not found for " + bean.getName());
+                indexer.index(in);
+            }
+        }
+        index = indexer.complete();
+    }
+
     @Test
     void serverController_isGatedByMcpEnabled() {
-        assertGatedByEnabled(McpServerController.class);
+        assertGatedByMcpEnabled(McpServerController.class);
     }
 
     @Test
-    void securityConfig_isGatedByMcpEnabled() {
-        assertGatedByEnabled(McpSecurityConfig.class);
-    }
-
-    @Test
-    void categoryToolsAndDescribeOperation_doNotNeedOwnGate() {
-        // The tool beans are only wired into the gated controller; sanity-check their signatures.
-        Class<?>[] tools = {
-            DescribeOperationTool.class,
-            StirlingConvertTool.class,
-            StirlingPagesTool.class,
-            StirlingMiscTool.class,
-            StirlingSecurityTool.class,
-            StirlingAiTool.class
-        };
-        for (Class<?> t : tools) {
+    void categoryTools_areGatedAndImplementMcpTool() {
+        for (Class<?> bean : GATED_BEANS) {
+            if (bean.equals(McpServerController.class)) {
+                continue;
+            }
             assertTrue(
-                    McpTool.class.isAssignableFrom(t),
-                    t.getSimpleName() + " must implement McpTool");
-            assertNotNull(
-                    t.getAnnotation(org.springframework.stereotype.Component.class),
-                    t.getSimpleName() + " must be @Component");
+                    McpTool.class.isAssignableFrom(bean),
+                    bean.getSimpleName() + " must implement McpTool");
+            assertGatedByMcpEnabled(bean);
         }
     }
 
-    @Test
-    void mcpBeans_areNotSaasProfileRestricted() {
-        // Beans gate on mcp.enabled only; no @Profile, so MCP can run under the saas profile too.
-        Class<?>[] beans = {
-            McpServerController.class,
-            McpSecurityConfig.class,
-            McpToolCatalog.class,
-            EngineCapabilityClient.class,
-            McpOperationExecutor.class,
-            DescribeOperationTool.class,
-            StirlingAiTool.class,
-            StirlingConvertTool.class,
-            StirlingMiscTool.class,
-            StirlingPagesTool.class,
-            StirlingSecurityTool.class,
-            StirlingUploadTool.class,
-            StirlingDownloadTool.class
-        };
-        for (Class<?> bean : beans) {
-            assertNull(
-                    bean.getAnnotation(Profile.class),
-                    bean.getSimpleName()
-                            + " must not be @Profile-restricted so MCP can run under saas");
-        }
-    }
-
-    private static void assertGatedByEnabled(Class<?> beanClass) {
-        ConditionalOnProperty conditional = beanClass.getAnnotation(ConditionalOnProperty.class);
-        assertNotNull(conditional, beanClass.getSimpleName() + " missing @ConditionalOnProperty");
-        assertTrue(
-                Arrays.asList(conditional.name()).contains("mcp.enabled")
-                        || Arrays.asList(conditional.value()).contains("mcp.enabled"),
+    private static void assertGatedByMcpEnabled(Class<?> beanClass) {
+        ClassInfo info = index.getClassByName(DotName.createSimple(beanClass.getName()));
+        assertNotNull(info, beanClass.getSimpleName() + " was not indexed");
+        AnnotationInstance gate = info.declaredAnnotation(LOOKUP_IF_PROPERTY);
+        assertNotNull(
+                gate,
+                beanClass.getSimpleName()
+                        + " must be gated with @LookupIfProperty(name=\"mcp.enabled\")");
+        assertEquals(
+                "mcp.enabled",
+                gate.value("name").asString(),
                 beanClass.getSimpleName() + " must gate on mcp.enabled");
         assertEquals(
                 "true",
-                conditional.havingValue(),
+                gate.value("stringValue").asString(),
                 beanClass.getSimpleName() + " must require mcp.enabled=true");
     }
 }

app/proprietary/src/test/java/stirling/software/proprietary/security/controller/api/AuthControllerLoginTest.java

@@ -1,31 +1,31 @@
 package stirling.software.proprietary.security.controller.api;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
+import java.security.Principal;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.http.MediaType;
-import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
-import org.springframework.security.core.context.SecurityContextHolder;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+import io.quarkus.security.identity.SecurityIdentity;
+import io.vertx.core.http.HttpServerRequest;
+
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.Response;
 
 import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.model.enumeration.Role;
@@ -41,17 +41,21 @@ import stirling.software.proprietary.security.service.RefreshRateLimitService;
 import stirling.software.proprietary.security.service.TotpService;
 import stirling.software.proprietary.security.service.UserService;
 
-import tools.jackson.databind.ObjectMapper;
-import tools.jackson.databind.json.JsonMapper;
-
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
+/**
+ * Migration (Spring MockMvc -> direct JAX-RS calls): {@code AuthController} now returns {@code
+ * jakarta.ws.rs.core.Response}. {@code /login} binds a typed {@code UsernameAndPassMfa} body plus
+ * the Vert.x {@code HttpServerRequest} and JAX-RS {@code HttpHeaders} (for IP / User-Agent); {@code
+ * /refresh} reads the bearer token from the {@code Authorization} header via {@code HttpHeaders}
+ * (replacing {@code jwtService.extractToken(HttpServletRequest)}); and {@code /me} reads the caller
+ * from the injected Quarkus {@code SecurityIdentity} (replacing {@code SecurityContextHolder}). The
+ * controller has no constructor (field injection only), so the collaborators and config are
+ * assigned directly. {@code applicationProperties.setSecurity(securityProperties)} keeps the same
+ * Jwt config visible through both injection points.
+ */
 @ExtendWith(MockitoExtension.class)
 class AuthControllerLoginTest {
 
-    private final ObjectMapper objectMapper = JsonMapper.builder().build();
-
-    private MockMvc mockMvc;
-    private ApplicationProperties.Security securityProperties;
+    private static final String USERNAME = "user@example.com";
 
     @Mock private UserService userService;
     @Mock private JwtServiceInterface jwtService;
@@ -60,6 +64,10 @@ class AuthControllerLoginTest {
     @Mock private MfaService mfaService;
     @Mock private TotpService totpService;
     @Mock private RefreshRateLimitService refreshRateLimitService;
+    @Mock private SecurityIdentity securityIdentity;
+
+    private ApplicationProperties.Security securityProperties;
+    private AuthController controller;
 
     @BeforeEach
     void setUp() {
@@ -71,238 +79,238 @@ class AuthControllerLoginTest {
         ApplicationProperties applicationProperties = new ApplicationProperties();
         applicationProperties.setSecurity(securityProperties);
 
-        AuthController controller =
-                new AuthController(
-                        userService,
-                        jwtService,
-                        userDetailsService,
-                        loginAttemptService,
-                        mfaService,
-                        totpService,
-                        refreshRateLimitService,
-                        securityProperties,
-                        applicationProperties,
-                        new stirling.software.proprietary.service.AiUserDataService(null));
-        mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
+        controller = new AuthController();
+        // @Inject fields are not populated without a CDI container; wire them directly.
+        controller.userService = userService;
+        controller.jwtService = jwtService;
+        controller.userDetailsService = userDetailsService;
+        controller.loginAttemptService = loginAttemptService;
+        controller.mfaService = mfaService;
+        controller.totpService = totpService;
+        controller.refreshRateLimitService = refreshRateLimitService;
+        controller.securityProperties = securityProperties;
+        controller.applicationProperties = applicationProperties;
+        controller.securityIdentity = securityIdentity;
+    }
+
+    /** Vert.x request whose remote address is unknown (controller treats this as a null IP). */
+    private HttpServerRequest webRequest() {
+        HttpServerRequest request = mock(HttpServerRequest.class);
+        lenient().when(request.remoteAddress()).thenReturn(null);
+        return request;
+    }
+
+    /** JAX-RS headers with no User-Agent and, optionally, a bearer Authorization header. */
+    private HttpHeaders headers(String bearerToken) {
+        HttpHeaders httpHeaders = mock(HttpHeaders.class);
+        lenient().when(httpHeaders.getHeaderString("User-Agent")).thenReturn(null);
+        lenient()
+                .when(httpHeaders.getHeaderString(HttpHeaders.AUTHORIZATION))
+                .thenReturn(bearerToken == null ? null : "Bearer " + bearerToken);
+        return httpHeaders;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, Object> body(Response response) {
+        return (Map<String, Object>) response.getEntity();
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, Object> nested(Response response, String key) {
+        return (Map<String, Object>) body(response).get(key);
     }
 
     @Test
-    void loginRejectsWhenUserPassDisabled() throws Exception {
+    void loginRejectsWhenUserPassDisabled() {
         securityProperties.setLoginMethod(
                 ApplicationProperties.Security.LoginMethods.OAUTH2.toString());
         UsernameAndPassMfa payload = buildPayload(null);
 
-        mockMvc.perform(
-                        post("/api/v1/auth/login")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(objectMapper.writeValueAsString(payload)))
-                .andExpect(status().isForbidden())
-                .andExpect(
-                        jsonPath("$.error")
-                                .value(
-                                        "Username/password authentication is not enabled. Please use the configured authentication method."));
+        Response response = controller.login(payload, webRequest(), headers(null));
+
+        assertEquals(Response.Status.FORBIDDEN.getStatusCode(), response.getStatus());
+        assertEquals(
+                "Username/password authentication is not enabled. Please use the configured"
+                        + " authentication method.",
+                body(response).get("error"));
 
         verify(userDetailsService, never()).loadUserByUsername(any());
     }
 
     @Test
-    void loginBlockedAccountReturnsUnauthorized() throws Exception {
+    void loginBlockedAccountReturnsUnauthorized() {
         UsernameAndPassMfa payload = buildPayload(null);
-        when(loginAttemptService.isBlocked("user@example.com")).thenReturn(true);
+        when(loginAttemptService.isBlocked(USERNAME)).thenReturn(true);
 
-        mockMvc.perform(
-                        post("/api/v1/auth/login")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(objectMapper.writeValueAsString(payload)))
-                .andExpect(status().isUnauthorized())
-                .andExpect(
-                        jsonPath("$.error")
-                                .value("Account is locked due to too many failed attempts"));
+        Response response = controller.login(payload, webRequest(), headers(null));
+
+        assertEquals(Response.Status.UNAUTHORIZED.getStatusCode(), response.getStatus());
+        assertEquals(
+                "Account is locked due to too many failed attempts", body(response).get("error"));
 
         verify(loginAttemptService, never()).loginSucceeded(any());
     }
 
     @Test
-    void loginRequiresMfaCodeWhenEnabled() throws Exception {
+    void loginRequiresMfaCodeWhenEnabled() {
         UsernameAndPassMfa payload = buildPayload(null);
         User user = buildUser();
-        when(userDetailsService.loadUserByUsername("user@example.com")).thenReturn(user);
+        when(userDetailsService.loadUserByUsername(USERNAME)).thenReturn(user);
         when(userService.isPasswordCorrect(user, "pw")).thenReturn(true);
         when(mfaService.isMfaEnabled(user)).thenReturn(true);
 
-        mockMvc.perform(
-                        post("/api/v1/auth/login")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(objectMapper.writeValueAsString(payload)))
-                .andExpect(status().isUnauthorized())
-                .andExpect(jsonPath("$.error").value("mfa_required"));
+        Response response = controller.login(payload, webRequest(), headers(null));
+
+        assertEquals(Response.Status.UNAUTHORIZED.getStatusCode(), response.getStatus());
+        assertEquals("mfa_required", body(response).get("error"));
 
         verify(loginAttemptService, never()).loginSucceeded(any());
     }
 
     @Test
-    void loginFailsWhenPasswordIncorrect() throws Exception {
+    void loginFailsWhenPasswordIncorrect() {
         UsernameAndPassMfa payload = buildPayload(null);
         User user = buildUser();
-        when(userDetailsService.loadUserByUsername("user@example.com")).thenReturn(user);
+        when(userDetailsService.loadUserByUsername(USERNAME)).thenReturn(user);
         when(userService.isPasswordCorrect(user, "pw")).thenReturn(false);
 
-        mockMvc.perform(
-                        post("/api/v1/auth/login")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(objectMapper.writeValueAsString(payload)))
-                .andExpect(status().isUnauthorized())
-                .andExpect(jsonPath("$.error").value("Invalid username or password"));
+        Response response = controller.login(payload, webRequest(), headers(null));
 
-        verify(loginAttemptService).loginFailed("user@example.com");
+        assertEquals(Response.Status.UNAUTHORIZED.getStatusCode(), response.getStatus());
+        assertEquals("Invalid username or password", body(response).get("error"));
+
+        verify(loginAttemptService).loginFailed(USERNAME);
     }
 
     @Test
-    void loginSucceedsAndGeneratesToken() throws Exception {
+    void loginSucceedsAndGeneratesToken() {
         UsernameAndPassMfa payload = buildPayload(null);
         User user = buildUser();
-        when(userDetailsService.loadUserByUsername("user@example.com")).thenReturn(user);
+        when(userDetailsService.loadUserByUsername(USERNAME)).thenReturn(user);
         when(userService.isPasswordCorrect(user, "pw")).thenReturn(true);
         when(mfaService.isMfaEnabled(user)).thenReturn(false);
-        when(jwtService.generateToken(eq("user@example.com"), any(Map.class)))
-                .thenReturn("token-123");
+        when(jwtService.generateToken(eq(USERNAME), any(Map.class))).thenReturn("token-123");
 
-        mockMvc.perform(
-                        post("/api/v1/auth/login")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(objectMapper.writeValueAsString(payload)))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.session.access_token").value("token-123"))
-                .andExpect(jsonPath("$.user.username").value("user@example.com"));
+        Response response = controller.login(payload, webRequest(), headers(null));
 
-        verify(loginAttemptService).loginSucceeded("user@example.com");
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertEquals("token-123", nested(response, "session").get("access_token"));
+        assertEquals(USERNAME, nested(response, "user").get("username"));
+
+        verify(loginAttemptService).loginSucceeded(USERNAME);
     }
 
     @Test
-    void refreshReturnsUnauthorizedWhenTokenMissing() throws Exception {
-        when(jwtService.extractToken(any())).thenReturn(null);
-        mockMvc.perform(post("/api/v1/auth/refresh"))
-                .andExpect(status().isUnauthorized())
-                .andExpect(jsonPath("$.error").value("No token found"));
+    void refreshReturnsUnauthorizedWhenTokenMissing() {
+        Response response = controller.refresh(headers(null));
+
+        assertEquals(Response.Status.UNAUTHORIZED.getStatusCode(), response.getStatus());
+        assertEquals("No token found", body(response).get("error"));
     }
 
     @Test
-    void refreshReturnsNewTokenWhenValid() throws Exception {
+    void refreshReturnsNewTokenWhenValid() {
         User user = buildUser();
-        when(jwtService.extractToken(any())).thenReturn("old");
         Map<String, Object> claims = new HashMap<>();
-        claims.put("sub", "user@example.com");
+        claims.put("sub", USERNAME);
         claims.put("exp", new Date(System.currentTimeMillis() + 60_000));
         when(jwtService.extractClaimsAllowExpired("old")).thenReturn(claims);
         // Rate limiting is not checked for valid tokens, so no stub needed
-        when(userDetailsService.loadUserByUsername("user@example.com")).thenReturn(user);
-        when(jwtService.generateToken(eq("user@example.com"), any(Map.class)))
-                .thenReturn("new-token");
+        when(userDetailsService.loadUserByUsername(USERNAME)).thenReturn(user);
+        when(jwtService.generateToken(eq(USERNAME), any(Map.class))).thenReturn("new-token");
 
-        mockMvc.perform(post("/api/v1/auth/refresh"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.user").exists())
-                .andExpect(jsonPath("$.session.access_token").value("new-token"))
-                .andExpect(
-                        jsonPath("$.session.expires_in")
-                                .value(3600)); // 60 minutes * 60 = 3600 seconds
+        Response response = controller.refresh(headers("old"));
 
-        // clearRefreshAttempts is intentionally not called - tokens expire naturally after grace
-        // period
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertEquals(USERNAME, nested(response, "user").get("username"));
+        assertEquals("new-token", nested(response, "session").get("access_token"));
+        assertEquals(3600L, nested(response, "session").get("expires_in")); // 60 minutes * 60
     }
 
     @Test
-    void refreshRejectsTokenExpiredBeyondGrace() throws Exception {
-        when(jwtService.extractToken(any())).thenReturn("old");
+    void refreshRejectsTokenExpiredBeyondGrace() {
         Map<String, Object> claims = new HashMap<>();
-        claims.put("sub", "user@example.com");
-        claims.put(
-                "exp",
-                new Date(
-                        System.currentTimeMillis()
-                                - (10 * 60_000))); // 10 minutes ago, beyond 5 minute grace
+        claims.put("sub", USERNAME);
+        // 10 minutes ago, beyond the 5 minute grace
+        claims.put("exp", new Date(System.currentTimeMillis() - (10 * 60_000)));
         when(jwtService.extractClaimsAllowExpired("old")).thenReturn(claims);
 
-        mockMvc.perform(post("/api/v1/auth/refresh"))
-                .andExpect(status().isUnauthorized())
-                .andExpect(jsonPath("$.error").value("Token refresh failed"));
+        Response response = controller.refresh(headers("old"));
+
+        assertEquals(Response.Status.UNAUTHORIZED.getStatusCode(), response.getStatus());
+        assertEquals("Token refresh failed", body(response).get("error"));
 
         verify(userDetailsService, never()).loadUserByUsername(any());
         verify(refreshRateLimitService, never()).isRefreshAllowed(any(), any(Long.class));
     }
 
     @Test
-    void refreshAcceptsTokenExpiredWithinGrace() throws Exception {
+    void refreshAcceptsTokenExpiredWithinGrace() {
         User user = buildUser();
-        when(jwtService.extractToken(any())).thenReturn("old");
         Map<String, Object> claims = new HashMap<>();
-        claims.put("sub", "user@example.com");
-        claims.put(
-                "exp",
-                new Date(
-                        System.currentTimeMillis()
-                                - 60_000)); // 1 minute ago, within 5 minute grace
+        claims.put("sub", USERNAME);
+        // 1 minute ago, within the 5 minute grace
+        claims.put("exp", new Date(System.currentTimeMillis() - 60_000));
         when(jwtService.extractClaimsAllowExpired("old")).thenReturn(claims);
         when(refreshRateLimitService.isRefreshAllowed(any(), any(Long.class))).thenReturn(true);
-        when(userDetailsService.loadUserByUsername("user@example.com")).thenReturn(user);
-        when(jwtService.generateToken(eq("user@example.com"), any(Map.class)))
-                .thenReturn("new-token");
+        when(userDetailsService.loadUserByUsername(USERNAME)).thenReturn(user);
+        when(jwtService.generateToken(eq(USERNAME), any(Map.class))).thenReturn("new-token");
 
-        mockMvc.perform(post("/api/v1/auth/refresh"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.session.access_token").value("new-token"));
+        Response response = controller.refresh(headers("old"));
 
-        // clearRefreshAttempts is intentionally not called - tokens expire naturally after grace
-        // period
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertEquals("new-token", nested(response, "session").get("access_token"));
     }
 
     @Test
-    void refreshRejectsWhenRateLimitExceeded() throws Exception {
-        when(jwtService.extractToken(any())).thenReturn("old");
+    void refreshRejectsWhenRateLimitExceeded() {
         Map<String, Object> claims = new HashMap<>();
-        claims.put("sub", "user@example.com");
+        claims.put("sub", USERNAME);
         claims.put("exp", new Date(System.currentTimeMillis() - 60_000)); // 1 minute ago
         when(jwtService.extractClaimsAllowExpired("old")).thenReturn(claims);
         when(refreshRateLimitService.isRefreshAllowed(any(), any(Long.class))).thenReturn(false);
 
-        mockMvc.perform(post("/api/v1/auth/refresh"))
-                .andExpect(status().isTooManyRequests())
-                .andExpect(jsonPath("$.error").value("Too many refresh attempts"))
-                .andExpect(jsonPath("$.max_attempts").exists());
+        Response response = controller.refresh(headers("old"));
+
+        assertEquals(429, response.getStatus());
+        assertEquals("Too many refresh attempts", body(response).get("error"));
+        org.junit.jupiter.api.Assertions.assertNotNull(body(response).get("max_attempts"));
 
         verify(userDetailsService, never()).loadUserByUsername(any());
         verify(refreshRateLimitService, never()).clearRefreshAttempts(any());
     }
 
     @Test
-    void getCurrentUserReturnsUnauthorizedWhenAnonymous() throws Exception {
-        SecurityContextHolder.clearContext();
+    void getCurrentUserReturnsUnauthorizedWhenAnonymous() {
+        when(securityIdentity.isAnonymous()).thenReturn(true);
 
-        mockMvc.perform(get("/api/v1/auth/me"))
-                .andExpect(status().isUnauthorized())
-                .andExpect(jsonPath("$.error").value("Not authenticated"));
+        Response response = controller.getCurrentUser();
+
+        assertEquals(Response.Status.UNAUTHORIZED.getStatusCode(), response.getStatus());
+        assertEquals("Not authenticated", body(response).get("error"));
     }
 
     @Test
-    void getCurrentUserReturnsUserDetails() throws Exception {
+    void getCurrentUserReturnsUserDetails() {
         User user = buildUser();
-        UsernamePasswordAuthenticationToken authentication =
-                new UsernamePasswordAuthenticationToken(user, null, user.getAuthorities());
-        SecurityContextHolder.getContext().setAuthentication(authentication);
+        Principal principal = mock(Principal.class);
+        when(principal.getName()).thenReturn(USERNAME);
+        when(securityIdentity.isAnonymous()).thenReturn(false);
+        when(securityIdentity.getPrincipal()).thenReturn(principal);
+        when(userDetailsService.loadUserByUsername(USERNAME)).thenReturn(user);
 
-        mockMvc.perform(get("/api/v1/auth/me"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.user.username").value("user@example.com"))
-                .andExpect(
-                        jsonPath("$.user.authenticationType")
-                                .value(AuthenticationType.WEB.name().toLowerCase()));
+        Response response = controller.getCurrentUser();
 
-        SecurityContextHolder.clearContext();
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertEquals(USERNAME, nested(response, "user").get("username"));
+        assertEquals(
+                AuthenticationType.WEB.name().toLowerCase(),
+                nested(response, "user").get("authenticationType"));
     }
 
     private User buildUser() {
         User user = new User();
-        user.setUsername("user@example.com");
+        user.setUsername(USERNAME);
         user.setEnabled(true);
         user.setAuthenticationType(AuthenticationType.WEB);
 
@@ -314,7 +322,7 @@ class AuthControllerLoginTest {
 
     private UsernameAndPassMfa buildPayload(String mfaCode) {
         UsernameAndPassMfa payload = new UsernameAndPassMfa();
-        payload.setUsername("user@example.com");
+        payload.setUsername(USERNAME);
         payload.setPassword("pw");
         payload.setMfaCode(mfaCode);
         return payload;

app/proprietary/src/test/java/stirling/software/proprietary/security/controller/api/AuthControllerMfaTest.java

@@ -1,34 +1,30 @@
 package stirling.software.proprietary.security.controller.api;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
-import java.util.List;
+import java.security.Principal;
 import java.util.Map;
 import java.util.Optional;
 
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.http.MediaType;
-import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
-import org.springframework.security.core.Authentication;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+import io.quarkus.security.identity.SecurityIdentity;
+
+import jakarta.ws.rs.core.Response;
 
 import stirling.software.proprietary.security.model.AuthenticationType;
 import stirling.software.proprietary.security.model.User;
+import stirling.software.proprietary.security.model.api.user.MfaCodeRequest;
 import stirling.software.proprietary.security.service.CustomUserDetailsService;
 import stirling.software.proprietary.security.service.JwtServiceInterface;
 import stirling.software.proprietary.security.service.LoginAttemptService;
@@ -36,119 +32,150 @@ import stirling.software.proprietary.security.service.MfaService;
 import stirling.software.proprietary.security.service.TotpService;
 import stirling.software.proprietary.security.service.UserService;
 
-import tools.jackson.databind.ObjectMapper;
-import tools.jackson.databind.json.JsonMapper;
-
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
+/**
+ * Migration (Spring MockMvc -> direct JAX-RS calls): {@code AuthController} MFA endpoints now
+ * return {@code jakarta.ws.rs.core.Response} and read the caller from the injected Quarkus {@code
+ * SecurityIdentity} (was a Spring {@code Authentication}/{@code Principal} via {@code
+ * .principal()}). The enable/disable endpoints bind a typed {@code MfaCodeRequest} body (was a JSON
+ * string). The controller has no constructor (field injection only), so the collaborators and the
+ * {@code SecurityIdentity} are assigned directly. Anonymous access is simulated with {@code
+ * isAnonymous()==true}.
+ */
 @ExtendWith(MockitoExtension.class)
 class AuthControllerMfaTest {
 
     private static final String USERNAME = "user@example.com";
 
-    private final ObjectMapper objectMapper = JsonMapper.builder().build();
-
-    private MockMvc mockMvc;
-    private Authentication authentication;
-    private User user;
-
     @Mock private UserService userService;
     @Mock private JwtServiceInterface jwtService;
     @Mock private CustomUserDetailsService userDetailsService;
     @Mock private LoginAttemptService loginAttemptService;
     @Mock private MfaService mfaService;
     @Mock private TotpService totpService;
+    @Mock private SecurityIdentity securityIdentity;
 
-    @InjectMocks private AuthController authController;
+    private AuthController authController;
+    private User user;
 
     @BeforeEach
     void setUp() {
-        mockMvc = MockMvcBuilders.standaloneSetup(authController).build();
-        authentication = new UsernamePasswordAuthenticationToken(USERNAME, "password", List.of());
+        authController = new AuthController();
+        // @Inject fields are not populated without a CDI container; wire them directly.
+        authController.userService = userService;
+        authController.jwtService = jwtService;
+        authController.userDetailsService = userDetailsService;
+        authController.loginAttemptService = loginAttemptService;
+        authController.mfaService = mfaService;
+        authController.totpService = totpService;
+        authController.securityIdentity = securityIdentity;
+
         user = new User();
         user.setUsername(USERNAME);
         user.setAuthenticationType(AuthenticationType.WEB);
     }
 
+    /** Make {@code securityIdentity} report an authenticated principal named {@link #USERNAME}. */
+    private void authenticated() {
+        Principal principal = mock(Principal.class);
+        lenient().when(principal.getName()).thenReturn(USERNAME);
+        lenient().when(securityIdentity.isAnonymous()).thenReturn(false);
+        lenient().when(securityIdentity.getPrincipal()).thenReturn(principal);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, Object> body(Response response) {
+        return (Map<String, Object>) response.getEntity();
+    }
+
+    private static MfaCodeRequest code(String value) {
+        MfaCodeRequest request = new MfaCodeRequest();
+        request.setCode(value);
+        return request;
+    }
+
     @Test
-    void setupMfaRequiresAuthentication() throws Exception {
-        mockMvc.perform(get("/api/v1/auth/mfa/setup"))
-                .andExpect(status().isUnauthorized())
-                .andExpect(content().json("{\"error\":\"Not authenticated\"}"));
+    void setupMfaRequiresAuthentication() {
+        when(securityIdentity.isAnonymous()).thenReturn(true);
+
+        Response response = authController.setupMfa();
+
+        assertEquals(Response.Status.UNAUTHORIZED.getStatusCode(), response.getStatus());
+        assertEquals("Not authenticated", body(response).get("error"));
     }
 
     @Test
     void setupMfaReturnsSecretAndUri() throws Exception {
+        authenticated();
         when(userService.findByUsernameIgnoreCaseWithSettings(USERNAME))
                 .thenReturn(Optional.of(user));
         when(mfaService.isMfaEnabled(user)).thenReturn(false);
         when(totpService.generateSecret()).thenReturn("SECRET");
         when(totpService.buildOtpAuthUri(USERNAME, "SECRET")).thenReturn("otpauth://test");
 
-        mockMvc.perform(get("/api/v1/auth/mfa/setup").principal(authentication))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.secret").value("SECRET"))
-                .andExpect(jsonPath("$.otpauthUri").value("otpauth://test"));
+        Response response = authController.setupMfa();
+
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertEquals("SECRET", body(response).get("secret"));
+        assertEquals("otpauth://test", body(response).get("otpauthUri"));
 
         verify(mfaService).setSecret(user, "SECRET");
     }
 
     @Test
-    void setupMfaReturnsConflictWhenAlreadyEnabled() throws Exception {
+    void setupMfaReturnsConflictWhenAlreadyEnabled() {
+        authenticated();
         when(userService.findByUsernameIgnoreCaseWithSettings(USERNAME))
                 .thenReturn(Optional.of(user));
         when(mfaService.isMfaEnabled(user)).thenReturn(true);
 
-        mockMvc.perform(get("/api/v1/auth/mfa/setup").principal(authentication))
-                .andExpect(status().isConflict())
-                .andExpect(content().json("{\"error\":\"MFA already enabled\"}"));
+        Response response = authController.setupMfa();
+
+        assertEquals(Response.Status.CONFLICT.getStatusCode(), response.getStatus());
+        assertEquals("MFA already enabled", body(response).get("error"));
 
         verify(totpService, never()).generateSecret();
     }
 
     @Test
-    void setupMfaRejectsNonWebAuthenticationType() throws Exception {
+    void setupMfaRejectsNonWebAuthenticationType() {
         user.setAuthenticationType(AuthenticationType.OAUTH2);
+        authenticated();
         when(userService.findByUsernameIgnoreCaseWithSettings(USERNAME))
                 .thenReturn(Optional.of(user));
 
-        mockMvc.perform(get("/api/v1/auth/mfa/setup").principal(authentication))
-                .andExpect(status().isForbidden())
-                .andExpect(
-                        content()
-                                .json(
-                                        "{\"error\":\"MFA settings are only available for web accounts\"}"));
+        Response response = authController.setupMfa();
+
+        assertEquals(Response.Status.FORBIDDEN.getStatusCode(), response.getStatus());
+        assertEquals(
+                "MFA settings are only available for web accounts", body(response).get("error"));
     }
 
     @Test
-    void enableMfaRejectsMissingCode() throws Exception {
+    void enableMfaRejectsMissingCode() {
+        authenticated();
         when(userService.findByUsernameIgnoreCaseWithSettings(USERNAME))
                 .thenReturn(Optional.of(user));
         when(mfaService.getSecret(user)).thenReturn("SECRET");
 
-        mockMvc.perform(
-                        post("/api/v1/auth/mfa/enable")
-                                .principal(authentication)
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content("{}"))
-                .andExpect(status().isBadRequest())
-                .andExpect(content().json("{\"error\":\"MFA code is required\"}"));
+        Response response = authController.enableMfa(code(null));
+
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
+        assertEquals("MFA code is required", body(response).get("error"));
     }
 
     @Test
     void enableMfaCompletesWorkflow() throws Exception {
+        authenticated();
         when(userService.findByUsernameIgnoreCaseWithSettings(USERNAME))
                 .thenReturn(Optional.of(user));
         when(mfaService.getSecret(user)).thenReturn("SECRET");
         when(totpService.getValidTimeStep("SECRET", "123456")).thenReturn(42L);
         when(mfaService.isTotpStepUsable(user, 42L)).thenReturn(true);
 
-        mockMvc.perform(
-                        post("/api/v1/auth/mfa/enable")
-                                .principal(authentication)
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(objectMapper.writeValueAsString(Map.of("code", "123456"))))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.enabled").value(true));
+        Response response = authController.enableMfa(code("123456"));
+
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertEquals(true, body(response).get("enabled"));
 
         verify(mfaService).enableMfa(user);
         verify(mfaService).markTotpStepUsed(user, 42L);
@@ -157,6 +184,7 @@ class AuthControllerMfaTest {
 
     @Test
     void disableMfaCompletesWorkflow() throws Exception {
+        authenticated();
         when(userService.findByUsernameIgnoreCaseWithSettings(USERNAME))
                 .thenReturn(Optional.of(user));
         when(mfaService.isMfaEnabled(user)).thenReturn(true);
@@ -164,31 +192,26 @@ class AuthControllerMfaTest {
         when(totpService.getValidTimeStep("SECRET", "654321")).thenReturn(7L);
         when(mfaService.isTotpStepUsable(user, 7L)).thenReturn(true);
 
-        mockMvc.perform(
-                        post("/api/v1/auth/mfa/disable")
-                                .principal(authentication)
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(objectMapper.writeValueAsString(Map.of("code", "654321"))))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.enabled").value(false));
+        Response response = authController.disableMfa(code("654321"));
+
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertEquals(false, body(response).get("enabled"));
 
         verify(mfaService).disableMfa(user);
         verify(mfaService).markTotpStepUsed(user, 7L);
     }
 
     @Test
-    void disableMfaReturnsDisabledWhenNotEnabled() throws Exception {
+    void disableMfaReturnsDisabledWhenNotEnabled() {
+        authenticated();
         when(userService.findByUsernameIgnoreCaseWithSettings(USERNAME))
                 .thenReturn(Optional.of(user));
         when(mfaService.isMfaEnabled(user)).thenReturn(false);
 
-        mockMvc.perform(
-                        post("/api/v1/auth/mfa/disable")
-                                .principal(authentication)
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(objectMapper.writeValueAsString(Map.of("code", "654321"))))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.enabled").value(false));
+        Response response = authController.disableMfa(code("654321"));
+
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertEquals(false, body(response).get("enabled"));
 
         verify(mfaService, never()).getSecret(user);
         verifyNoInteractions(totpService);
@@ -196,25 +219,29 @@ class AuthControllerMfaTest {
 
     @Test
     void cancelMfaSetupClearsPendingSecret() throws Exception {
+        authenticated();
         when(userService.findByUsernameIgnoreCaseWithSettings(USERNAME))
                 .thenReturn(Optional.of(user));
 
-        mockMvc.perform(post("/api/v1/auth/mfa/setup/cancel").principal(authentication))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.cleared").value(true));
+        Response response = authController.cancelMfaSetup();
+
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertEquals(true, body(response).get("cleared"));
 
         verify(mfaService).clearPendingSecret(user);
     }
 
     @Test
     void cancelMfaSetupReturnsConflictWhenEnabled() throws Exception {
+        authenticated();
         when(userService.findByUsernameIgnoreCaseWithSettings(USERNAME))
                 .thenReturn(Optional.of(user));
         when(mfaService.isMfaEnabled(user)).thenReturn(true);
 
-        mockMvc.perform(post("/api/v1/auth/mfa/setup/cancel").principal(authentication))
-                .andExpect(status().isConflict())
-                .andExpect(content().json("{\"error\":\"MFA already enabled\"}"));
+        Response response = authController.cancelMfaSetup();
+
+        assertEquals(Response.Status.CONFLICT.getStatusCode(), response.getStatus());
+        assertEquals("MFA already enabled", body(response).get("error"));
 
         verify(mfaService, never()).clearPendingSecret(user);
     }

app/proprietary/src/test/java/stirling/software/proprietary/security/controller/api/EmailControllerTest.java

@@ -1,54 +1,54 @@
 package stirling.software.proprietary.security.controller.api;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doThrow;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
 import java.util.stream.Stream;
 
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 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.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.mail.MailSendException;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
 
 import jakarta.mail.MessagingException;
+import jakarta.ws.rs.core.Response;
 
+import stirling.software.common.testsupport.TestFileUploads;
 import stirling.software.proprietary.security.model.api.Email;
 import stirling.software.proprietary.security.service.EmailService;
 
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
+/**
+ * Migration (Spring MockMvc -> direct JAX-RS calls): {@code
+ * EmailController.sendEmailWithAttachment} now binds multipart form fields directly ({@code
+ * FileUpload} + form strings) and returns {@code jakarta.ws.rs.core.Response}. The Spring-specific
+ * {@code org.springframework.mail.MailSendException} branch was removed in the migration (see the
+ * controller's TODO), so the two MockMvc cases that exercised it are dropped; only the success and
+ * generic {@code MessagingException} -> 500 paths remain. The {@code mail.enabled} config field is
+ * package-private and assigned directly here since there is no CDI container.
+ */
 @ExtendWith(MockitoExtension.class)
 class EmailControllerTest {
 
-    private MockMvc mockMvc;
-
     @Mock private EmailService emailService;
 
-    @InjectMocks private EmailController emailController;
+    private EmailController emailController;
 
     @BeforeEach
     void setUp() {
-        mockMvc = MockMvcBuilders.standaloneSetup(emailController).build();
+        emailController = new EmailController(emailService);
+        // @ConfigProperty field is not populated without a CDI container; enable mail explicitly.
+        emailController.mailEnabled = true;
     }
 
-    @ParameterizedTest(name = "Case {index}: exception={0}, includeTo={1}")
+    @ParameterizedTest(name = "Case {index}: exception={0}")
     @MethodSource("emailParams")
     void shouldHandleEmailRequests(
-            Exception serviceException,
-            boolean includeTo,
-            int expectedStatus,
-            String expectedContent)
+            Exception serviceException, int expectedStatus, String expectedContent)
             throws Exception {
         if (serviceException == null) {
             doNothing().when(emailService).sendEmailWithAttachment(any(Email.class));
@@ -56,41 +56,32 @@ class EmailControllerTest {
             doThrow(serviceException).when(emailService).sendEmailWithAttachment(any(Email.class));
         }
 
-        var request =
-                multipart("/api/v1/general/send-email")
-                        .file("fileInput", "dummy-content".getBytes())
-                        .param("subject", "Test Email")
-                        .param("body", "This is a test email.");
+        Response response =
+                emailController.sendEmailWithAttachment(
+                        TestFileUploads.of(
+                                "dummy-content".getBytes(),
+                                "fileInput",
+                                "application/octet-stream"),
+                        "test@example.com",
+                        "Test Email",
+                        "This is a test email.");
 
-        if (includeTo) {
-            request = request.param("to", "test@example.com");
-        }
-
-        mockMvc.perform(request)
-                .andExpect(status().is(expectedStatus))
-                .andExpect(content().string(expectedContent));
+        assertEquals(expectedStatus, response.getStatus());
+        assertEquals(expectedContent, response.getEntity());
     }
 
     static Stream<Arguments> emailParams() {
         return Stream.of(
                 // success case
-                Arguments.of(null, true, 200, "Email sent successfully"),
+                Arguments.of(null, 200, "Email sent successfully"),
                 // generic messaging error
                 Arguments.of(
                         new MessagingException("Failed to send email"),
-                        true,
                         500,
                         "Failed to send email: Failed to send email"),
-                // missing 'to' results in MailSendException
-                Arguments.of(
-                        new MailSendException("Invalid Addresses"),
-                        false,
-                        500,
-                        "Invalid Addresses"),
-                // invalid email address formatting
+                // invalid email address formatting surfaces as a MessagingException
                 Arguments.of(
                         new MessagingException("Invalid Addresses"),
-                        true,
                         500,
                         "Failed to send email: Invalid Addresses"));
     }

app/proprietary/src/test/java/stirling/software/proprietary/security/controller/api/InviteLinkControllerTest.java

@@ -1,27 +1,29 @@
 package stirling.software.proprietary.security.controller.api;
 
-import static org.hamcrest.Matchers.startsWith;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
 import java.security.Principal;
 import java.time.LocalDateTime;
+import java.util.Map;
 import java.util.Optional;
 
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+import jakarta.enterprise.inject.Instance;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.SecurityContext;
+import jakarta.ws.rs.core.UriInfo;
 
 import stirling.software.common.model.ApplicationProperties;
 import stirling.software.common.model.enumeration.Role;
@@ -34,7 +36,15 @@ import stirling.software.proprietary.security.service.TeamService;
 import stirling.software.proprietary.security.service.UserService;
 import stirling.software.proprietary.service.UserLicenseSettingsService;
 
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
+/**
+ * Migration (Spring MockMvc -> direct JAX-RS calls): {@code InviteLinkController} now returns
+ * {@code jakarta.ws.rs.core.Response}, reads the admin caller from an injected JAX-RS {@code
+ * SecurityContext} (was a Spring {@code Principal} parameter), persists via the Panache repository
+ * ({@code persist(...)} replaces {@code save(...)}) and resolves the optional {@code EmailService}
+ * through a CDI {@code Instance}. The controller has no constructor (field injection only), so the
+ * collaborators are assigned directly. Each test invokes the endpoint and asserts the status /
+ * entity map.
+ */
 @ExtendWith(MockitoExtension.class)
 class InviteLinkControllerTest {
 
@@ -45,8 +55,9 @@ class InviteLinkControllerTest {
     @Mock private UserLicenseSettingsService userLicenseSettingsService;
 
     private ApplicationProperties applicationProperties;
-    private MockMvc mockMvc;
-    private Principal adminPrincipal;
+    private InviteLinkController controller;
+    private SecurityContext adminSecurityContext;
+    private UriInfo uriInfo;
 
     @BeforeEach
     void setUp() {
@@ -55,59 +66,79 @@ class InviteLinkControllerTest {
         applicationProperties.getMail().setInviteLinkExpiryHours(24);
         applicationProperties.getSystem().setFrontendUrl("https://frontend.example.com");
 
-        adminPrincipal = () -> "admin";
+        controller = new InviteLinkController();
+        // @Inject fields are not populated without a CDI container; wire them directly.
+        controller.inviteTokenRepository = inviteTokenRepository;
+        controller.teamRepository = teamRepository;
+        controller.userService = userService;
+        controller.applicationProperties = applicationProperties;
+        controller.emailService = emailServiceInstance();
+        controller.userLicenseSettingsService = userLicenseSettingsService;
 
-        InviteLinkController controller =
-                new InviteLinkController(
-                        inviteTokenRepository,
-                        teamRepository,
-                        userService,
-                        applicationProperties,
-                        Optional.of(emailService),
-                        userLicenseSettingsService);
-        mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
+        Principal adminPrincipal = () -> "admin";
+        adminSecurityContext = mock(SecurityContext.class);
+        lenient().when(adminSecurityContext.getUserPrincipal()).thenReturn(adminPrincipal);
+        // No configured-URL fallback is taken in these tests (frontendUrl is always set), so
+        // UriInfo
+        // is never read; a bare mock satisfies the @Context parameter.
+        uriInfo = mock(UriInfo.class);
+    }
+
+    @SuppressWarnings("unchecked")
+    private Instance<EmailService> emailServiceInstance() {
+        Instance<EmailService> instance = mock(Instance.class);
+        lenient().when(instance.isResolvable()).thenReturn(true);
+        lenient().when(instance.get()).thenReturn(emailService);
+        return instance;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, Object> body(Response response) {
+        return (Map<String, Object>) response.getEntity();
+    }
+
+    private Response generate(String email) {
+        return controller.generateInviteLink(
+                email, null, null, null, null, null, adminSecurityContext, uriInfo);
     }
 
     @Test
-    void generateInviteLinkRejectsWhenInvitesDisabled() throws Exception {
+    void generateInviteLinkRejectsWhenInvitesDisabled() {
         applicationProperties.getMail().setEnableInvites(false);
 
-        mockMvc.perform(post("/api/v1/invite/generate").principal(adminPrincipal))
-                .andExpect(status().isBadRequest())
-                .andExpect(jsonPath("$.error").value("Email invites are not enabled"));
+        Response response = generate(null);
 
-        verify(inviteTokenRepository, never()).save(any());
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
+        assertEquals("Email invites are not enabled", body(response).get("error"));
+
+        verify(inviteTokenRepository, never()).persist(any(InviteToken.class));
     }
 
     @Test
-    void generateInviteLinkRejectsInvalidEmail() throws Exception {
+    void generateInviteLinkRejectsInvalidEmail() {
         applicationProperties.getMail().setEnableInvites(true);
 
-        mockMvc.perform(
-                        post("/api/v1/invite/generate")
-                                .principal(adminPrincipal)
-                                .param("email", "not-an-email"))
-                .andExpect(status().isBadRequest())
-                .andExpect(jsonPath("$.error").value("Invalid email address"));
+        Response response = generate("not-an-email");
+
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
+        assertEquals("Invalid email address", body(response).get("error"));
     }
 
     @Test
-    void generateInviteLinkBlocksOnLicenseLimit() throws Exception {
+    void generateInviteLinkBlocksOnLicenseLimit() {
         applicationProperties.getPremium().setEnabled(true);
         when(userService.getTotalUsersCount()).thenReturn(1L);
         when(inviteTokenRepository.countActiveInvites(any(LocalDateTime.class))).thenReturn(0L);
         when(userLicenseSettingsService.calculateMaxAllowedUsers()).thenReturn(1);
 
-        mockMvc.perform(
-                        post("/api/v1/invite/generate")
-                                .principal(adminPrincipal)
-                                .param("email", "new@ex.com"))
-                .andExpect(status().isBadRequest())
-                .andExpect(jsonPath("$.error").value(startsWith("License limit reached")));
+        Response response = generate("new@ex.com");
+
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
+        assertThat((String) body(response).get("error")).startsWith("License limit reached");
     }
 
     @Test
-    void generateInviteLinkAllowedOnServerLicense() throws Exception {
+    void generateInviteLinkAllowedOnServerLicense() {
         // SERVER license has raw maxUsers=0, but calculateMaxAllowedUsers() returns
         // Integer.MAX_VALUE
         applicationProperties.getPremium().setEnabled(true);
@@ -122,15 +153,13 @@ class InviteLinkControllerTest {
         when(teamRepository.findByName(TeamService.DEFAULT_TEAM_NAME))
                 .thenReturn(Optional.of(defaultTeam));
 
-        mockMvc.perform(
-                        post("/api/v1/invite/generate")
-                                .principal(adminPrincipal)
-                                .param("email", "new@ex.com"))
-                .andExpect(status().isOk());
+        Response response = generate("new@ex.com");
+
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
     }
 
     @Test
-    void generateInviteLinkBuildsFrontendUrl() throws Exception {
+    void generateInviteLinkBuildsFrontendUrl() {
         Team defaultTeam = new Team();
         defaultTeam.setId(5L);
         defaultTeam.setName(TeamService.DEFAULT_TEAM_NAME);
@@ -139,30 +168,28 @@ class InviteLinkControllerTest {
         when(userService.usernameExistsIgnoreCase("new@example.com")).thenReturn(false);
         when(inviteTokenRepository.findByEmail("new@example.com")).thenReturn(Optional.empty());
 
-        mockMvc.perform(
-                        post("/api/v1/invite/generate")
-                                .principal(adminPrincipal)
-                                .param("email", "new@example.com"))
-                .andExpect(status().isOk())
-                .andExpect(
-                        jsonPath("$.inviteUrl")
-                                .value(startsWith("https://frontend.example.com/invite/")))
-                .andExpect(jsonPath("$.email").value("new@example.com"));
+        Response response = generate("new@example.com");
 
-        verify(inviteTokenRepository).save(any());
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertThat((String) body(response).get("inviteUrl"))
+                .startsWith("https://frontend.example.com/invite/");
+        assertEquals("new@example.com", body(response).get("email"));
+
+        verify(inviteTokenRepository).persist(any(InviteToken.class));
     }
 
     @Test
-    void validateInviteTokenReturnsNotFoundWhenExpired() throws Exception {
+    void validateInviteTokenReturnsNotFoundWhenExpired() {
         InviteToken expired = new InviteToken();
         expired.setToken("abc");
         expired.setExpiresAt(LocalDateTime.now().minusHours(1));
         expired.setRole(Role.USER.getRoleId());
         when(inviteTokenRepository.findByToken("abc")).thenReturn(Optional.of(expired));
 
-        mockMvc.perform(get("/api/v1/invite/validate/abc"))
-                .andExpect(status().isNotFound())
-                .andExpect(jsonPath("$.error").value("Invalid invite link"));
+        Response response = controller.validateInviteToken("abc");
+
+        assertEquals(Response.Status.NOT_FOUND.getStatusCode(), response.getStatus());
+        assertEquals("Invalid invite link", body(response).get("error"));
     }
 
     @Test
@@ -176,15 +203,13 @@ class InviteLinkControllerTest {
         when(inviteTokenRepository.findByToken("abc")).thenReturn(Optional.of(invite));
         when(userService.usernameExistsIgnoreCase("new@example.com")).thenReturn(false);
 
-        mockMvc.perform(
-                        post("/api/v1/invite/accept/abc")
-                                .param("email", "new@example.com")
-                                .param("password", "password123"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.message").value("Account created successfully"))
-                .andExpect(jsonPath("$.username").value("new@example.com"));
+        Response response = controller.acceptInvite("abc", "new@example.com", "password123");
+
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertEquals("Account created successfully", body(response).get("message"));
+        assertEquals("new@example.com", body(response).get("username"));
 
         verify(userService).saveUserCore(any());
-        verify(inviteTokenRepository).save(invite);
+        verify(inviteTokenRepository).persist(invite);
     }
 }

app/proprietary/src/test/java/stirling/software/proprietary/security/controller/api/UIDataTessdataControllerTest.java

@@ -1,110 +1,139 @@
 package stirling.software.proprietary.security.controller.api;
 
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.IOException;
+import java.lang.reflect.Method;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
+import java.util.Map;
 
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 import org.mockito.Mockito;
-import org.springframework.http.MediaType;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+import jakarta.ws.rs.core.Response;
 
 import stirling.software.common.configuration.RuntimePathConfig;
 
+import tools.jackson.databind.ObjectMapper;
 import tools.jackson.databind.json.JsonMapper;
 
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
+/**
+ * Migration (Spring MockMvc -> direct JAX-RS calls): {@code UIDataTessdataController} now returns
+ * {@code jakarta.ws.rs.core.Response} with HTTP statuses expressed via {@link Response.Status} /
+ * numeric codes (207 Multi-Status, 502 Bad Gateway). The {@code download} endpoint binds a typed
+ * request DTO that is a {@code private static} nested class, so it is built by deserializing JSON
+ * via the project {@link JsonMapper} and the endpoint is invoked reflectively; the JSON download
+ * responses are plain {@code Map} entities asserted directly. The {@code tessdata-languages}
+ * endpoint returns a private response DTO that is converted to a {@code Map} for assertions. The
+ * {@code protected} test seams ({@code getRemoteTessdataLanguages}, {@code downloadLanguageFile},
+ * {@code isWritableDirectory}) are still overridden via anonymous subclasses.
+ */
 class UIDataTessdataControllerTest {
 
+    private static final ObjectMapper MAPPER = JsonMapper.builder().build();
+
+    private static RuntimePathConfig pathConfig(String tessDataPath) {
+        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
+        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(tessDataPath);
+        return runtimePathConfig;
+    }
+
+    /**
+     * Build the {@code TessdataDownloadRequest} (a private nested type) from JSON and invoke the
+     * public {@code downloadTessdataLanguages} method reflectively.
+     */
+    private static Response download(UIDataTessdataController controller, String json)
+            throws Exception {
+        Class<?> requestType =
+                Class.forName(
+                        "stirling.software.proprietary.security.controller.api"
+                                + ".UIDataTessdataController$TessdataDownloadRequest");
+        Object request = MAPPER.readValue(json, requestType);
+        Method method =
+                UIDataTessdataController.class.getDeclaredMethod(
+                        "downloadTessdataLanguages", requestType);
+        method.setAccessible(true);
+        return (Response) method.invoke(controller, request);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, Object> map(Response response) {
+        Object entity = response.getEntity();
+        if (entity instanceof Map) {
+            return (Map<String, Object>) entity;
+        }
+        // Private response DTO (TessdataLanguagesResponse) -> convert via getters.
+        return MAPPER.convertValue(entity, Map.class);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static List<Object> list(Map<String, Object> map, String key) {
+        return (List<Object>) map.get(key);
+    }
+
     @Test
     void downloadTessdataLanguages_withEmptyList_returnsBadRequest() throws Exception {
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn("ignored/path");
-
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig("ignored/path"), MAPPER) {
                     @Override
                     protected List<String> getRemoteTessdataLanguages() {
                         return List.of("eng");
                     }
                 };
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
 
-        mvc.perform(
-                        post("/api/v1/ui-data/tessdata/download")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content("{\"languages\":[]}"))
-                .andExpect(status().isBadRequest())
-                .andExpect(jsonPath("$.message").value("No languages provided for download"));
+        Response response = download(controller, "{\"languages\":[]}");
+
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
+        assertEquals("No languages provided for download", map(response).get("message"));
     }
 
     @Test
     void downloadTessdataLanguages_blocksPathTraversal(@TempDir Path tempDir) throws Exception {
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(tempDir.toString());
-
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig(tempDir.toString()), MAPPER) {
                     @Override
                     protected List<String> getRemoteTessdataLanguages() {
                         return List.of("eng");
                     }
                 };
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
 
-        mvc.perform(
-                        post("/api/v1/ui-data/tessdata/download")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content("{\"languages\":[\"../evil\"]}"))
-                .andExpect(status().isBadGateway())
-                .andExpect(jsonPath("$.downloaded").isArray())
-                .andExpect(jsonPath("$.downloaded").isEmpty())
-                .andExpect(jsonPath("$.failed[0]").value("../evil"));
+        Response response = download(controller, "{\"languages\":[\"../evil\"]}");
+
+        assertEquals(Response.Status.BAD_GATEWAY.getStatusCode(), response.getStatus());
+        assertTrue(list(map(response), "downloaded").isEmpty());
+        assertEquals("../evil", list(map(response), "failed").get(0));
 
         // Ensure no file was written outside the tessdata directory
         Path escapedPath = tempDir.resolve("../evil.traineddata").normalize();
-        assert Files.notExists(escapedPath) : "Traversal path should not be written";
+        assertTrue(Files.notExists(escapedPath), "Traversal path should not be written");
     }
 
     @Test
     void downloadTessdataLanguages_rejectsUnknownLanguage(@TempDir Path tempDir) throws Exception {
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(tempDir.toString());
-
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig(tempDir.toString()), MAPPER) {
                     @Override
                     protected List<String> getRemoteTessdataLanguages() {
                         return List.of("eng");
                     }
                 };
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
 
-        mvc.perform(
-                        post("/api/v1/ui-data/tessdata/download")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content("{\"languages\":[\"fra\"]}"))
-                .andExpect(status().isBadGateway())
-                .andExpect(jsonPath("$.downloaded").isEmpty())
-                .andExpect(jsonPath("$.failed[0]").value("fra"));
+        Response response = download(controller, "{\"languages\":[\"fra\"]}");
+
+        assertEquals(Response.Status.BAD_GATEWAY.getStatusCode(), response.getStatus());
+        assertTrue(list(map(response), "downloaded").isEmpty());
+        assertEquals("fra", list(map(response), "failed").get(0));
     }
 
     @Test
     void downloadTessdataLanguages_successAndFailureMixed(@TempDir Path tempDir) throws Exception {
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(tempDir.toString());
-
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig(tempDir.toString()), MAPPER) {
                     @Override
                     protected List<String> getRemoteTessdataLanguages() {
                         return List.of("eng", "fra");
@@ -125,72 +154,51 @@ class UIDataTessdataControllerTest {
                     }
                 };
 
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
+        Response response = download(controller, "{\"languages\":[\"eng\",\"fra\"]}");
 
-        mvc.perform(
-                        post("/api/v1/ui-data/tessdata/download")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content("{\"languages\":[\"eng\",\"fra\"]}"))
-                .andExpect(status().isMultiStatus())
-                .andExpect(jsonPath("$.downloaded[0]").value("eng"))
-                .andExpect(jsonPath("$.failed[0]").value("fra"));
+        assertEquals(207, response.getStatus());
+        assertEquals("eng", list(map(response), "downloaded").get(0));
+        assertEquals("fra", list(map(response), "failed").get(0));
     }
 
     @Test
     void downloadTessdataLanguages_handlesInvalidSanitizedLanguage(@TempDir Path tempDir)
             throws Exception {
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(tempDir.toString());
-
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig(tempDir.toString()), MAPPER) {
                     @Override
                     protected List<String> getRemoteTessdataLanguages() {
                         return List.of("eng");
                     }
                 };
 
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
+        Response response = download(controller, "{\"languages\":[\"eng/\"]}");
 
-        mvc.perform(
-                        post("/api/v1/ui-data/tessdata/download")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content("{\"languages\":[\"eng/\"]}"))
-                .andExpect(status().isBadGateway())
-                .andExpect(jsonPath("$.downloaded").isEmpty())
-                .andExpect(jsonPath("$.failed[0]").value("eng/"));
+        assertEquals(Response.Status.BAD_GATEWAY.getStatusCode(), response.getStatus());
+        assertTrue(list(map(response), "downloaded").isEmpty());
+        assertEquals("eng/", list(map(response), "failed").get(0));
     }
 
     @Test
     void downloadTessdataLanguages_returnsForbiddenWhenNotWritable(@TempDir Path tempDir)
             throws Exception {
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(tempDir.toString());
-
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig(tempDir.toString()), MAPPER) {
                     @Override
                     protected boolean isWritableDirectory(Path dir) {
                         return false;
                     }
                 };
 
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
+        Response response = download(controller, "{\"languages\":[\"eng\"]}");
 
-        mvc.perform(
-                        post("/api/v1/ui-data/tessdata/download")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content("{\"languages\":[\"eng\"]}"))
-                .andExpect(status().isForbidden());
+        assertEquals(Response.Status.FORBIDDEN.getStatusCode(), response.getStatus());
     }
 
     @Test
     void downloadTessdataLanguages_handlesNetworkFailure(@TempDir Path tempDir) throws Exception {
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(tempDir.toString());
-
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig(tempDir.toString()), MAPPER) {
                     @Override
                     protected List<String> getRemoteTessdataLanguages() {
                         return List.of("eng");
@@ -203,25 +211,17 @@ class UIDataTessdataControllerTest {
                     }
                 };
 
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
+        Response response = download(controller, "{\"languages\":[\"eng\"]}");
 
-        mvc.perform(
-                        post("/api/v1/ui-data/tessdata/download")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content("{\"languages\":[\"eng\"]}"))
-                .andExpect(status().isBadGateway())
-                .andExpect(jsonPath("$.downloaded").isArray())
-                .andExpect(jsonPath("$.downloaded").isEmpty())
-                .andExpect(jsonPath("$.failed[0]").value("eng"));
+        assertEquals(Response.Status.BAD_GATEWAY.getStatusCode(), response.getStatus());
+        assertTrue(list(map(response), "downloaded").isEmpty());
+        assertEquals("eng", list(map(response), "failed").get(0));
     }
 
     @Test
     void downloadTessdataLanguages_allSuccess(@TempDir Path tempDir) throws Exception {
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(tempDir.toString());
-
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig(tempDir.toString()), MAPPER) {
                     @Override
                     protected List<String> getRemoteTessdataLanguages() {
                         return List.of("eng");
@@ -239,16 +239,11 @@ class UIDataTessdataControllerTest {
                     }
                 };
 
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
+        Response response = download(controller, "{\"languages\":[\"eng\"]}");
 
-        mvc.perform(
-                        post("/api/v1/ui-data/tessdata/download")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content("{\"languages\":[\"eng\"]}"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.downloaded[0]").value("eng"))
-                .andExpect(jsonPath("$.failed").isArray())
-                .andExpect(jsonPath("$.failed").isEmpty());
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertEquals("eng", list(map(response), "downloaded").get(0));
+        assertTrue(list(map(response), "failed").isEmpty());
     }
 
     @Test
@@ -258,105 +253,88 @@ class UIDataTessdataControllerTest {
         Files.createFile(tempDir.resolve("deu.traineddata"));
         Files.createFile(tempDir.resolve("osd.traineddata")); // should be filtered
 
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(tempDir.toString());
-
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig(tempDir.toString()), MAPPER) {
                     @Override
                     protected List<String> getRemoteTessdataLanguages() {
                         return List.of("eng", "fra");
                     }
                 };
 
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
+        Response response = controller.getTessdataLanguages();
 
-        mvc.perform(get("/api/v1/ui-data/tessdata-languages"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.installed[0]").value("deu"))
-                .andExpect(jsonPath("$.installed[1]").value("eng"))
-                .andExpect(jsonPath("$.available[0]").value("eng"))
-                .andExpect(jsonPath("$.available[1]").value("fra"))
-                .andExpect(jsonPath("$.writable").value(true));
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        Map<String, Object> body = map(response);
+        assertEquals("deu", list(body, "installed").get(0));
+        assertEquals("eng", list(body, "installed").get(1));
+        assertEquals("eng", list(body, "available").get(0));
+        assertEquals("fra", list(body, "available").get(1));
+        assertEquals(true, body.get("writable"));
     }
 
     @Test
     void tessdataLanguages_emptyDirectory(@TempDir Path tempDir) throws Exception {
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(tempDir.toString());
-
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig(tempDir.toString()), MAPPER) {
                     @Override
                     protected List<String> getRemoteTessdataLanguages() {
                         return List.of("eng");
                     }
                 };
 
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
+        Response response = controller.getTessdataLanguages();
 
-        mvc.perform(get("/api/v1/ui-data/tessdata-languages"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.installed").isArray())
-                .andExpect(jsonPath("$.installed").isEmpty())
-                .andExpect(jsonPath("$.available[0]").value("eng"))
-                .andExpect(jsonPath("$.writable").value(true));
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        Map<String, Object> body = map(response);
+        assertTrue(list(body, "installed").isEmpty());
+        assertEquals("eng", list(body, "available").get(0));
+        assertEquals(true, body.get("writable"));
     }
 
     @Test
     void tessdataLanguages_nonTraineddataFilesAreIgnored(@TempDir Path tempDir) throws Exception {
         Files.createFile(tempDir.resolve("notes.txt"));
 
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(tempDir.toString());
-
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig(tempDir.toString()), MAPPER) {
                     @Override
                     protected List<String> getRemoteTessdataLanguages() {
                         return List.of("eng");
                     }
                 };
 
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
+        Response response = controller.getTessdataLanguages();
 
-        mvc.perform(get("/api/v1/ui-data/tessdata-languages"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.installed").isArray())
-                .andExpect(jsonPath("$.installed").isEmpty())
-                .andExpect(jsonPath("$.writable").value(true));
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        Map<String, Object> body = map(response);
+        assertTrue(list(body, "installed").isEmpty());
+        assertEquals(true, body.get("writable"));
     }
 
     @Test
     void tessdataLanguages_handlesNonExistentDirectory(@TempDir Path tempDir) throws Exception {
         Path missingDir = tempDir.resolve("missing");
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(missingDir.toString());
 
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig(missingDir.toString()), MAPPER) {
                     @Override
                     protected List<String> getRemoteTessdataLanguages() {
                         return List.of("eng");
                     }
                 };
 
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
+        Response response = controller.getTessdataLanguages();
 
-        mvc.perform(get("/api/v1/ui-data/tessdata-languages"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.installed").isArray())
-                .andExpect(jsonPath("$.installed").isEmpty())
-                .andExpect(jsonPath("$.writable").value(true));
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        Map<String, Object> body = map(response);
+        assertTrue(list(body, "installed").isEmpty());
+        assertEquals(true, body.get("writable"));
     }
 
     @Test
     void tessdataLanguages_marksNotWritable(@TempDir Path tempDir) throws Exception {
-        RuntimePathConfig runtimePathConfig = Mockito.mock(RuntimePathConfig.class);
-        Mockito.when(runtimePathConfig.getTessDataPath()).thenReturn(tempDir.toString());
-
         UIDataTessdataController controller =
-                new UIDataTessdataController(runtimePathConfig, JsonMapper.builder().build()) {
+                new UIDataTessdataController(pathConfig(tempDir.toString()), MAPPER) {
                     @Override
                     protected boolean isWritableDirectory(Path dir) {
                         return false;
@@ -368,10 +346,9 @@ class UIDataTessdataControllerTest {
                     }
                 };
 
-        MockMvc mvc = MockMvcBuilders.standaloneSetup(controller).build();
+        Response response = controller.getTessdataLanguages();
 
-        mvc.perform(get("/api/v1/ui-data/tessdata-languages"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.writable").value(false));
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertFalse((Boolean) map(response).get("writable"));
     }
 }

app/proprietary/src/test/java/stirling/software/proprietary/security/controller/api/UserControllerTest.java

@@ -1,26 +1,26 @@
 package stirling.software.proprietary.security.controller.api;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
+import java.security.Principal;
+import java.util.Map;
 import java.util.Optional;
 
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.http.MediaType;
-import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
-import org.springframework.security.core.Authentication;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+import jakarta.enterprise.inject.Instance;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.SecurityContext;
 
 import stirling.software.common.model.ApplicationProperties;
 import stirling.software.proprietary.model.Team;
@@ -35,15 +35,17 @@ import stirling.software.proprietary.security.service.UserService;
 import stirling.software.proprietary.security.session.SessionPersistentRegistry;
 import stirling.software.proprietary.service.UserLicenseSettingsService;
 
-import tools.jackson.databind.ObjectMapper;
-import tools.jackson.databind.json.JsonMapper;
-
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
+/**
+ * Migration (Spring MockMvc -> direct JAX-RS calls): {@code UserController} now returns {@code
+ * jakarta.ws.rs.core.Response}; the caller identity is read from an injected JAX-RS {@code
+ * SecurityContext} (was a Spring {@code Authentication}/{@code Principal} method parameter) and the
+ * optional {@code EmailService} became a CDI {@code Instance<EmailService>}. Each test invokes the
+ * controller method directly and asserts the status code / entity map. The {@code securityContext}
+ * field is assigned a per-test mock (package-private, no CDI container).
+ */
 @ExtendWith(MockitoExtension.class)
 class UserControllerTest {
 
-    private final ObjectMapper objectMapper = JsonMapper.builder().build();
-
     @Mock private UserService userService;
     @Mock private SessionPersistentRegistry sessionRegistry;
     @Mock private TeamRepository teamRepository;
@@ -53,7 +55,7 @@ class UserControllerTest {
     @Mock private LoginAttemptService loginAttemptService;
 
     private ApplicationProperties applicationProperties;
-    private MockMvc mockMvc;
+    private UserController controller;
 
     @BeforeEach
     void setUp() {
@@ -61,17 +63,36 @@ class UserControllerTest {
         applicationProperties.getPremium().setMaxUsers(10);
         applicationProperties.getMail().setEnabled(true);
 
-        UserController controller =
+        controller =
                 new UserController(
                         userService,
                         sessionRegistry,
                         applicationProperties,
                         teamRepository,
                         userRepository,
-                        Optional.of(emailService),
+                        emailServiceInstance(),
                         licenseSettingsService,
                         loginAttemptService);
-        mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
+    }
+
+    @SuppressWarnings("unchecked")
+    private Instance<EmailService> emailServiceInstance() {
+        Instance<EmailService> instance = mock(Instance.class);
+        lenient().when(instance.isResolvable()).thenReturn(true);
+        lenient().when(instance.get()).thenReturn(emailService);
+        return instance;
+    }
+
+    private void authenticateAs(String username) {
+        SecurityContext securityContext = mock(SecurityContext.class);
+        Principal principal = () -> username;
+        lenient().when(securityContext.getUserPrincipal()).thenReturn(principal);
+        controller.securityContext = securityContext;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, Object> body(Response response) {
+        return (Map<String, Object>) response.getEntity();
     }
 
     @Test
@@ -81,12 +102,10 @@ class UserControllerTest {
         payload.setPassword("pw");
         when(userService.usernameExistsIgnoreCase("existing@example.com")).thenReturn(true);
 
-        mockMvc.perform(
-                        post("/api/v1/user/register")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(objectMapper.writeValueAsString(payload)))
-                .andExpect(status().isBadRequest())
-                .andExpect(jsonPath("$.error").value("User already exists"));
+        Response response = controller.register(payload);
+
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
+        assertEquals("User already exists", body(response).get("error"));
 
         verify(userService, never()).saveUserCore(any());
     }
@@ -110,12 +129,12 @@ class UserControllerTest {
         savedUser.setEnabled(false);
         when(userService.saveUserCore(any())).thenReturn(savedUser);
 
-        mockMvc.perform(
-                        post("/api/v1/user/register")
-                                .contentType(MediaType.APPLICATION_JSON)
-                                .content(objectMapper.writeValueAsString(payload)))
-                .andExpect(status().isCreated())
-                .andExpect(jsonPath("$.user.username").value("new@example.com"));
+        Response response = controller.register(payload);
+
+        assertEquals(Response.Status.CREATED.getStatusCode(), response.getStatus());
+        @SuppressWarnings("unchecked")
+        Map<String, Object> user = (Map<String, Object>) body(response).get("user");
+        assertEquals("new@example.com", user.get("username"));
     }
 
     @Test
@@ -124,31 +143,31 @@ class UserControllerTest {
         user.setUsername("admin");
         when(userService.usernameExistsIgnoreCase("admin")).thenReturn(true);
         when(userService.findByUsernameIgnoreCase("admin")).thenReturn(Optional.of(user));
-        Authentication authentication = new UsernamePasswordAuthenticationToken("admin", "pw");
+        authenticateAs("admin");
 
-        mockMvc.perform(
-                        post("/api/v1/user/admin/changeUserEnabled/admin")
-                                .param("enabled", "false")
-                                .principal(authentication))
-                .andExpect(status().isBadRequest())
-                .andExpect(jsonPath("$.error").value("Cannot disable your own account."));
+        Response response = controller.changeUserEnabled("admin", false);
+
+        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatus());
+        assertEquals("Cannot disable your own account.", body(response).get("error"));
     }
 
     @Test
-    void changePasswordRejectsMissingUser() throws Exception {
-        Authentication authentication = new UsernamePasswordAuthenticationToken("ghost", "pw");
+    void deleteUserRejectsMissingUser() throws Exception {
+        authenticateAs("ghost");
         when(userService.usernameExistsIgnoreCase("ghost")).thenReturn(false);
 
-        mockMvc.perform(post("/api/v1/user/admin/deleteUser/ghost").principal(authentication))
-                .andExpect(status().isNotFound())
-                .andExpect(jsonPath("$.error").value("User not found."));
+        Response response = controller.deleteUser("ghost");
+
+        assertEquals(Response.Status.NOT_FOUND.getStatusCode(), response.getStatus());
+        assertEquals("User not found.", body(response).get("error"));
     }
 
     @Test
-    void unlockUserCallsResetAttemptsAndReturnsOk() throws Exception {
-        mockMvc.perform(post("/api/v1/user/admin/unlockUser/lockeduser"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.message").value("User account unlocked successfully"));
+    void unlockUserCallsResetAttemptsAndReturnsOk() {
+        Response response = controller.unlockUser("lockeduser");
+
+        assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+        assertEquals("User account unlocked successfully", body(response).get("message"));
 
         verify(loginAttemptService).resetAttempts("lockeduser");
     }

app/proprietary/src/test/java/stirling/software/proprietary/service/AiWorkflowServiceTest.java

@@ -23,6 +23,7 @@ import java.io.InputStream;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;
 import java.util.zip.ZipEntry;
@@ -30,6 +31,7 @@ import java.util.zip.ZipOutputStream;
 
 import org.apache.pdfbox.pdmodel.PDDocument;
 import org.apache.pdfbox.pdmodel.PDPage;
+import org.jboss.resteasy.reactive.multipart.FileUpload;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -37,20 +39,22 @@ import org.junit.jupiter.api.io.TempDir;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.core.io.ByteArrayResource;
-import org.springframework.core.io.Resource;
-import org.springframework.http.ResponseEntity;
-import org.springframework.mock.web.MockMultipartFile;
-import org.springframework.util.MultiValueMap;
-import org.springframework.web.multipart.MultipartFile;
+
+import jakarta.enterprise.inject.Instance;
+import jakarta.ws.rs.core.Response;
 
 import stirling.software.common.model.ApplicationProperties;
+import stirling.software.common.model.MultipartFile;
+import stirling.software.common.model.io.InputStreamResource;
+import stirling.software.common.model.io.Resource;
 import stirling.software.common.service.CustomPDFDocumentFactory;
 import stirling.software.common.service.FileStorage;
 import stirling.software.common.service.FileStorage.StoredFile;
 import stirling.software.common.service.InternalApiClient;
 import stirling.software.common.service.InternalApiTimeoutException;
 import stirling.software.common.service.ToolMetadataService;
+import stirling.software.common.service.UserServiceInterface;
+import stirling.software.common.testsupport.TestFileUploads;
 import stirling.software.common.util.TempFileManager;
 import stirling.software.common.util.TempFileRegistry;
 import stirling.software.proprietary.model.api.ai.AiWorkflowFileInput;
@@ -87,6 +91,11 @@ class AiWorkflowServiceTest {
     @Mock private ToolMetadataService toolMetadataService;
     @Mock private FileIdStrategy fileIdStrategy;
     @Mock private AiEngineEndpointResolver endpointResolver;
+    // Optional security bean: the migrated constructor resolves it via Instance#isResolvable(), so
+    // a
+    // plain null is no longer valid. An unresolvable Instance reproduces the security-disabled
+    // path.
+    @Mock private Instance<UserServiceInterface> userServiceInstance;
 
     @TempDir Path tempDir;
 
@@ -102,12 +111,15 @@ class AiWorkflowServiceTest {
         tempFileManager = new TempFileManager(new TempFileRegistry(), props);
         objectMapper = JsonMapper.builder().build();
 
-        // Mock strategy yields the filename as id so each MockMultipartFile in a test gets a
-        // distinct collection key. Real strategy (ByteHashFileIdStrategy) hashes bytes.
+        // Mock strategy yields the filename as id so each input file in a test gets a distinct
+        // collection key. Real strategy (ByteHashFileIdStrategy) hashes bytes.
         lenient()
                 .when(fileIdStrategy.idFor(any(MultipartFile.class)))
                 .thenAnswer(inv -> ((MultipartFile) inv.getArgument(0)).getOriginalFilename());
 
+        // Security disabled: no UserServiceInterface bean is resolvable.
+        lenient().when(userServiceInstance.isResolvable()).thenReturn(false);
+
         PolicyExecutor policyExecutor =
                 new PolicyExecutor(
                         internalApiClient, toolMetadataService, tempFileManager, objectMapper);
@@ -122,14 +134,14 @@ class AiWorkflowServiceTest {
                         fileIdStrategy,
                         endpointResolver,
                         policyExecutor,
-                        null,
+                        userServiceInstance,
                         new ApplicationProperties());
         when(endpointResolver.getEnabledEndpointUrls()).thenReturn(List.of());
     }
 
     @Test
     void toolCallSingleFilePreservesInputFilename() throws IOException {
-        MockMultipartFile input = pdf("input.pdf", "original-pdf-bytes");
+        FileUpload input = pdf("input.pdf", "original-pdf-bytes");
         stubOrchestrator(
                 """
                 {"outcome":"tool_call","tool":"%s","parameters":{"angle":90},"rationale":"Rotating"}
@@ -153,7 +165,7 @@ class AiWorkflowServiceTest {
 
     @Test
     void toolCallZipResponseUnpacksIntoMultipleResults() throws IOException {
-        MockMultipartFile input = pdf("doc.pdf", "original");
+        FileUpload input = pdf("doc.pdf", "original");
         stubOrchestrator(
                 """
                 {"outcome":"tool_call","tool":"%s","parameters":{},"rationale":"Splitting"}
@@ -183,8 +195,8 @@ class AiWorkflowServiceTest {
 
     @Test
     void multiInputEndpointIsCalledOnceWithAllFiles() throws IOException {
-        MockMultipartFile a = pdf("a.pdf", "a-bytes");
-        MockMultipartFile b = pdf("b.pdf", "b-bytes");
+        FileUpload a = pdf("a.pdf", "a-bytes");
+        FileUpload b = pdf("b.pdf", "b-bytes");
         stubOrchestrator(
                 """
                 {"outcome":"tool_call","tool":"%s","parameters":{},"rationale":"Merging"}
@@ -196,7 +208,7 @@ class AiWorkflowServiceTest {
         stubFileStorage();
 
         AiWorkflowResponse result =
-                service.orchestrate(requestFor(new MockMultipartFile[] {a, b}, "merge these"));
+                service.orchestrate(requestFor(new FileUpload[] {a, b}, "merge these"));
 
         assertEquals(AiWorkflowOutcome.COMPLETED, result.getOutcome());
         assertEquals(1, result.getResultFiles().size());
@@ -207,8 +219,8 @@ class AiWorkflowServiceTest {
 
     @Test
     void singleInputEndpointIsCalledOncePerFile() throws IOException {
-        MockMultipartFile a = pdf("a.pdf", "a-bytes");
-        MockMultipartFile b = pdf("b.pdf", "b-bytes");
+        FileUpload a = pdf("a.pdf", "a-bytes");
+        FileUpload b = pdf("b.pdf", "b-bytes");
         stubOrchestrator(
                 """
                 {"outcome":"tool_call","tool":"%s","parameters":{"angle":90},"rationale":"Rotating"}
@@ -220,7 +232,7 @@ class AiWorkflowServiceTest {
         stubFileStorage();
 
         AiWorkflowResponse result =
-                service.orchestrate(requestFor(new MockMultipartFile[] {a, b}, "rotate both"));
+                service.orchestrate(requestFor(new FileUpload[] {a, b}, "rotate both"));
 
         assertEquals(AiWorkflowOutcome.COMPLETED, result.getOutcome());
         assertEquals(2, result.getResultFiles().size());
@@ -233,7 +245,7 @@ class AiWorkflowServiceTest {
 
     @Test
     void planExecutesStepsSequentially() throws IOException {
-        MockMultipartFile input = pdf("input.pdf", "bytes");
+        FileUpload input = pdf("input.pdf", "bytes");
         stubOrchestrator(
                 """
                 {
@@ -268,7 +280,7 @@ class AiWorkflowServiceTest {
         // from a single JSON form field via a property editor. The plan executor must
         // pre-serialize such lists rather than splitting them into repeated form fields.
         String editTextEndpoint = "/api/v1/general/edit-text";
-        MockMultipartFile input = pdf("input.pdf", "bytes");
+        FileUpload input = pdf("input.pdf", "bytes");
         stubOrchestrator(
                 """
                 {
@@ -290,11 +302,12 @@ class AiWorkflowServiceTest {
 
         service.orchestrate(requestFor(input, "find and replace"));
 
+        // The migrated InternalApiClient takes a Map<String, List<Object>> (replacing Spring's
+        // MultiValueMap) so the captured body is that map type.
         @SuppressWarnings("unchecked")
-        ArgumentCaptor<MultiValueMap<String, Object>> bodyCaptor =
-                ArgumentCaptor.forClass(MultiValueMap.class);
+        ArgumentCaptor<Map<String, List<Object>>> bodyCaptor = ArgumentCaptor.forClass(Map.class);
         verify(internalApiClient).post(eq(editTextEndpoint), bodyCaptor.capture());
-        MultiValueMap<String, Object> body = bodyCaptor.getValue();
+        Map<String, List<Object>> body = bodyCaptor.getValue();
 
         // The structured-list field must be serialized as ONE JSON-string entry, not multiple
         // entries.
@@ -317,7 +330,7 @@ class AiWorkflowServiceTest {
         // Endpoints like /misc/ocr-pdf bind List<String> via Spring's repeated-form-field
         // convention. The executor must preserve that behavior for primitive lists.
         String ocrEndpoint = "/api/v1/misc/ocr-pdf";
-        MockMultipartFile input = pdf("input.pdf", "bytes");
+        FileUpload input = pdf("input.pdf", "bytes");
         stubOrchestrator(
                 """
                 {
@@ -337,8 +350,7 @@ class AiWorkflowServiceTest {
         service.orchestrate(requestFor(input, "ocr"));
 
         @SuppressWarnings("unchecked")
-        ArgumentCaptor<MultiValueMap<String, Object>> bodyCaptor =
-                ArgumentCaptor.forClass(MultiValueMap.class);
+        ArgumentCaptor<Map<String, List<Object>>> bodyCaptor = ArgumentCaptor.forClass(Map.class);
         verify(internalApiClient).post(eq(ocrEndpoint), bodyCaptor.capture());
         List<Object> languages = bodyCaptor.getValue().get("languages");
         assertNotNull(languages);
@@ -350,7 +362,7 @@ class AiWorkflowServiceTest {
         // When an internal tool hangs, InternalApiClient throws InternalApiTimeoutException after
         // its read timeout fires. The workflow must convert that into a clean CANNOT_CONTINUE
         // outcome so the user sees an actionable message rather than the request hanging forever.
-        MockMultipartFile input = pdf("input.pdf", "bytes");
+        FileUpload input = pdf("input.pdf", "bytes");
         stubOrchestrator(
                 """
                 {"outcome":"tool_call","tool":"%s","parameters":{"angle":90},"rationale":"Rotating"}
@@ -381,7 +393,7 @@ class AiWorkflowServiceTest {
     void planTimeoutOnLaterStepStillSurfacesCleanly() throws IOException {
         // Multi-step plans must also handle a hung tool gracefully (no partial leaks) and the
         // failure message must identify which step failed so the user can iterate.
-        MockMultipartFile input = pdf("input.pdf", "bytes");
+        FileUpload input = pdf("input.pdf", "bytes");
         stubOrchestrator(
                 """
                 {
@@ -416,7 +428,7 @@ class AiWorkflowServiceTest {
 
     @Test
     void generateFileStoresContentDirectlyWithoutToolCall() throws IOException {
-        MockMultipartFile input = pdf("report.pdf", "bytes");
+        FileUpload input = pdf("report.pdf", "bytes");
         stubOrchestrator(
                 """
                 {
@@ -441,7 +453,7 @@ class AiWorkflowServiceTest {
 
     @Test
     void convertMarkdownRunsDeterministicConversionAndReturnsMdFile() throws IOException {
-        MockMultipartFile input = pdf("multi-column-test_lorem.pdf", "pdf-bytes");
+        FileUpload input = pdf("multi-column-test_lorem.pdf", "pdf-bytes");
         when(fileIdStrategy.idFor(any())).thenReturn("doc-1");
         stubOrchestrator(
                 """
@@ -470,7 +482,7 @@ class AiWorkflowServiceTest {
 
     @Test
     void toolCallWithoutEndpointFallsBackToCannotContinue() throws IOException {
-        MockMultipartFile input = pdf("input.pdf", "bytes");
+        FileUpload input = pdf("input.pdf", "bytes");
         stubOrchestrator("{\"outcome\":\"tool_call\",\"parameters\":{}}");
 
         AiWorkflowResponse result = service.orchestrate(requestFor(input, "do something"));
@@ -482,7 +494,7 @@ class AiWorkflowServiceTest {
 
     @Test
     void needIngestExtractsPageTextAndPostsThenRetries() throws IOException {
-        MockMultipartFile input = pdf("report.pdf", "bytes");
+        FileUpload input = pdf("report.pdf", "bytes");
         when(fileIdStrategy.idFor(any())).thenReturn("report-id");
 
         PDDocument document = new PDDocument();
@@ -556,8 +568,7 @@ class AiWorkflowServiceTest {
     }
 
     private void stubEndpoint(String endpoint, Resource body) {
-        when(internalApiClient.post(eq(endpoint), any(MultiValueMap.class)))
-                .thenReturn(ResponseEntity.ok(body));
+        when(internalApiClient.post(eq(endpoint), any())).thenReturn(Response.ok(body).build());
     }
 
     /**
@@ -576,37 +587,51 @@ class AiWorkflowServiceTest {
         return counter;
     }
 
-    private static MockMultipartFile pdf(String filename, String content) {
-        return new MockMultipartFile("fileInput", filename, "application/pdf", content.getBytes());
+    // The migrated AiWorkflowFileInput wraps a RESTEasy FileUpload (no plain byte[] setter), so
+    // each
+    // input part is built from the TestFileUploads fixture (a temp-file-backed FileUpload mock).
+    private static FileUpload pdf(String filename, String content) {
+        return TestFileUploads.of(content.getBytes(), filename, "application/pdf");
     }
 
-    private static AiWorkflowRequest requestFor(MockMultipartFile file, String message) {
-        return requestFor(new MockMultipartFile[] {file}, message);
+    private static AiWorkflowRequest requestFor(FileUpload file, String message) {
+        return requestFor(new FileUpload[] {file}, message);
     }
 
-    private static AiWorkflowRequest requestFor(MockMultipartFile[] files, String message) {
+    private static AiWorkflowRequest requestFor(FileUpload[] files, String message) {
         AiWorkflowRequest request = new AiWorkflowRequest();
         List<AiWorkflowFileInput> inputs = new ArrayList<>();
-        for (MockMultipartFile file : files) {
-            AiWorkflowFileInput fileInput = new AiWorkflowFileInput();
-            fileInput.setFileInput(file);
-            inputs.add(fileInput);
+        for (FileUpload file : files) {
+            inputs.add(new AiWorkflowFileInput(file));
         }
         request.setFileInputs(inputs);
         request.setUserMessage(message);
         return request;
     }
 
-    private static ByteArrayResource pdfResource(String content, String filename) {
-        return new ByteArrayResource(content.getBytes()) {
+    // No ByteArrayResource shim exists. Back a byte-array re-readable Resource so getInputStream()
+    // yields a fresh stream on each call (a single-input endpoint may be dispatched once per file,
+    // returning the same stubbed resource more than once). The filename drives the workflow's 1:1
+    // input/output name-preservation rule.
+    private static Resource byteResource(byte[] bytes, String filename) {
+        return new InputStreamResource(new ByteArrayInputStream(bytes), filename) {
             @Override
-            public String getFilename() {
-                return filename;
+            public InputStream getInputStream() {
+                return new ByteArrayInputStream(bytes);
+            }
+
+            @Override
+            public long contentLength() {
+                return bytes.length;
             }
         };
     }
 
-    private static ByteArrayResource zipResource(String filename, List<ZipEntryBytes> entries)
+    private static Resource pdfResource(String content, String filename) {
+        return byteResource(content.getBytes(), filename);
+    }
+
+    private static Resource zipResource(String filename, List<ZipEntryBytes> entries)
             throws IOException {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         try (ZipOutputStream zos = new ZipOutputStream(baos)) {
@@ -616,18 +641,7 @@ class AiWorkflowServiceTest {
                 zos.closeEntry();
             }
         }
-        byte[] zipBytes = baos.toByteArray();
-        return new ByteArrayResource(zipBytes) {
-            @Override
-            public String getFilename() {
-                return filename;
-            }
-
-            @Override
-            public InputStream getInputStream() {
-                return new ByteArrayInputStream(zipBytes);
-            }
-        };
+        return byteResource(baos.toByteArray(), filename);
     }
 
     private record ZipEntryBytes(String name, byte[] bytes) {

app/proprietary/src/test/java/stirling/software/proprietary/storage/controller/FileStorageControllerTest.java

@@ -7,49 +7,52 @@ import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.redirectedUrl;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
 import java.net.URI;
 import java.time.Duration;
 import java.util.Optional;
 
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpStatus;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.MvcResult;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.Response;
 
 import stirling.software.proprietary.security.model.User;
 import stirling.software.proprietary.storage.model.StoredFile;
 import stirling.software.proprietary.storage.provider.StorageProvider;
 import stirling.software.proprietary.storage.service.FileStorageService;
 
-@Disabled("TODO: Migration required - Spring Boot test framework not available in Quarkus")
+/**
+ * Migration (Spring MockMvc -> direct JAX-RS calls): {@code FileStorageController.downloadFile} now
+ * returns {@code jakarta.ws.rs.core.Response}. When the storage provider yields a signed URL the
+ * controller replies with a 302 ({@code Response.Status.FOUND}) carrying only a {@code Location}
+ * header. The collaborators are injected fields (no constructor), so the two used mocks are
+ * assigned directly. The regression fence (no session credentials forwarded on the redirect) is
+ * preserved by asserting the redirect Response carries no Authorization/Cookie/Set-Cookie headers.
+ */
 @ExtendWith(MockitoExtension.class)
 class FileStorageControllerTest {
 
+    private static final int FOUND = Response.Status.FOUND.getStatusCode();
     private static final String SIGNED_URL =
             "https://test-bucket.s3.example.com/signed-blob?X-Amz-Signature=abc";
 
     @Mock private FileStorageService fileStorageService;
     @Mock private StorageProvider storageProvider;
 
-    private MockMvc mockMvc;
+    private FileStorageController controller;
 
     @BeforeEach
     void setUp() {
-        FileStorageController controller =
-                new FileStorageController(fileStorageService, storageProvider);
-        mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
+        controller = new FileStorageController();
+        // @Inject fields are not populated without a CDI container; wire the mocks the download
+        // path uses directly (folderService / securityIdentity are not exercised here).
+        controller.fileStorageService = fileStorageService;
+        controller.storageProvider = storageProvider;
     }
 
     @Test
@@ -63,18 +66,16 @@ class FileStorageControllerTest {
                         eq("11/abc-doc.pdf"), any(Duration.class), anyBoolean(), anyString()))
                 .thenReturn(Optional.of(URI.create(SIGNED_URL)));
 
-        MvcResult result =
-                mockMvc.perform(get("/api/v1/storage/files/{fileId}/download", 77L))
-                        .andExpect(status().is(HttpStatus.FOUND.value()))
-                        .andExpect(header().string(HttpHeaders.LOCATION, SIGNED_URL))
-                        .andExpect(redirectedUrl(SIGNED_URL))
-                        .andReturn();
+        Response response = controller.downloadFile(77L, false);
+
+        assertThat(response.getStatus()).isEqualTo(FOUND);
+        assertThat(response.getLocation()).isEqualTo(URI.create(SIGNED_URL));
 
         // Regression fence: signed URLs delegate auth to the URL itself, so the redirect
         // response must NOT carry any session credentials forward.
-        assertThat(result.getResponse().getHeader(HttpHeaders.AUTHORIZATION)).isNull();
-        assertThat(result.getResponse().getHeader(HttpHeaders.COOKIE)).isNull();
-        assertThat(result.getResponse().getHeader(HttpHeaders.SET_COOKIE)).isNull();
+        assertThat(response.getHeaderString(HttpHeaders.AUTHORIZATION)).isNull();
+        assertThat(response.getHeaderString("Cookie")).isNull();
+        assertThat(response.getHeaderString("Set-Cookie")).isNull();
     }
 
     @Test
@@ -87,9 +88,10 @@ class FileStorageControllerTest {
                         eq("11/abc-doc.pdf"), any(Duration.class), eq(false), eq("doc.pdf")))
                 .thenReturn(Optional.of(URI.create(SIGNED_URL)));
 
-        mockMvc.perform(get("/api/v1/storage/files/{fileId}/download", 77L))
-                .andExpect(status().is(HttpStatus.FOUND.value()))
-                .andExpect(header().string(HttpHeaders.LOCATION, SIGNED_URL));
+        Response response = controller.downloadFile(77L, false);
+
+        assertThat(response.getStatus()).isEqualTo(FOUND);
+        assertThat(response.getLocation()).isEqualTo(URI.create(SIGNED_URL));
 
         verify(storageProvider)
                 .signedDownloadUrl(
@@ -106,9 +108,10 @@ class FileStorageControllerTest {
                         eq("11/abc-doc.pdf"), any(Duration.class), eq(true), eq("doc.pdf")))
                 .thenReturn(Optional.of(URI.create(SIGNED_URL)));
 
-        mockMvc.perform(get("/api/v1/storage/files/{fileId}/download", 77L).param("inline", "true"))
-                .andExpect(status().is(HttpStatus.FOUND.value()))
-                .andExpect(header().string(HttpHeaders.LOCATION, SIGNED_URL));
+        Response response = controller.downloadFile(77L, true);
+
+        assertThat(response.getStatus()).isEqualTo(FOUND);
+        assertThat(response.getLocation()).isEqualTo(URI.create(SIGNED_URL));
 
         verify(storageProvider)
                 .signedDownloadUrl(

app/proprietary/src/test/java/stirling/software/proprietary/workflow/controller/CertificateValidationIntegrationTest.java

@@ -1,27 +1,30 @@
 package stirling.software.proprietary.workflow.controller;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+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.ArgumentMatchers.anyBoolean;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Mockito.when;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
 import java.io.InputStream;
 import java.util.Optional;
 
+import org.jboss.resteasy.reactive.multipart.FileUpload;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.mock.web.MockMultipartFile;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+import jakarta.ws.rs.core.Response;
 
 import stirling.software.common.service.PdfSigningService;
+import stirling.software.common.testsupport.TestFileUploads;
+import stirling.software.proprietary.workflow.dto.CertificateValidationResponse;
 import stirling.software.proprietary.workflow.model.WorkflowParticipant;
 import stirling.software.proprietary.workflow.repository.WorkflowParticipantRepository;
 import stirling.software.proprietary.workflow.service.CertificateSubmissionValidator;
@@ -44,6 +47,12 @@ import tools.jackson.databind.ObjectMapper;
  *
  * Here both layers run together against real .p12 / .jks files, so any field-name mismatch, routing
  * bug, or wiring issue between controller and validator is caught.
+ *
+ * <p>MIGRATION (Spring -> Quarkus): the former standalone-MockMvc setup is replaced by direct calls
+ * on the JAX-RS handler (returns {@link Response}); the controller is wired by assigning its
+ * package-private {@code @Inject} fields. Certificate uploads are supplied as RESTEasy Reactive
+ * {@code FileUpload} stubs via {@link TestFileUploads}, and the {@code valid}/{@code error} fields
+ * are read off the {@code CertificateValidationResponse} entity.
  */
 @ExtendWith(MockitoExtension.class)
 class CertificateValidationIntegrationTest {
@@ -56,7 +65,7 @@ class CertificateValidationIntegrationTest {
     // Mock PdfSigningService so the test-sign step succeeds without a real PDF engine
     @Mock private PdfSigningService pdfSigningService;
 
-    private MockMvc mockMvc;
+    private WorkflowParticipantController controller;
 
     private static final String TOKEN = "integration-test-token";
 
@@ -66,15 +75,12 @@ class CertificateValidationIntegrationTest {
         CertificateSubmissionValidator realValidator =
                 new CertificateSubmissionValidator(pdfSigningService);
 
-        WorkflowParticipantController controller =
-                new WorkflowParticipantController(
-                        workflowSessionService,
-                        participantRepository,
-                        new ObjectMapper(),
-                        metadataEncryptionService,
-                        realValidator);
-
-        mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
+        controller = new WorkflowParticipantController();
+        controller.workflowSessionService = workflowSessionService;
+        controller.participantRepository = participantRepository;
+        controller.objectMapper = new ObjectMapper();
+        controller.metadataEncryptionService = metadataEncryptionService;
+        controller.certificateSubmissionValidator = realValidator;
 
         // Return a non-expired participant for all tests
         WorkflowParticipant participant = new WorkflowParticipant();
@@ -108,96 +114,91 @@ class CertificateValidationIntegrationTest {
         }
     }
 
-    private static MockMultipartFile p12Part(String filename) throws Exception {
-        return new MockMultipartFile(
-                "p12File", filename, "application/octet-stream", loadCert(filename));
+    private static FileUpload p12Part(String filename) throws Exception {
+        return TestFileUploads.of(loadCert(filename), filename, "application/octet-stream");
     }
 
-    private static MockMultipartFile jksPart(String filename) throws Exception {
-        return new MockMultipartFile(
-                "jksFile", filename, "application/octet-stream", loadCert(filename));
+    private static FileUpload jksPart(String filename) throws Exception {
+        return TestFileUploads.of(loadCert(filename), filename, "application/octet-stream");
+    }
+
+    private static CertificateValidationResponse body(Response resp) {
+        return (CertificateValidationResponse) resp.getEntity();
     }
 
     // ---- tests ----
 
     @Test
     void validP12_returnsValidTrueWithSubjectName() throws Exception {
-        mockMvc.perform(
-                        multipart("/api/v1/workflow/participant/validate-certificate")
-                                .file(p12Part("valid-test.p12"))
-                                .param("participantToken", TOKEN)
-                                .param("certType", "P12")
-                                .param("password", "testpass"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.valid").value(true))
-                .andExpect(jsonPath("$.subjectName").isNotEmpty())
-                .andExpect(jsonPath("$.notAfter").isNotEmpty());
+        Response resp =
+                controller.validateCertificate(
+                        TOKEN, "P12", "testpass", p12Part("valid-test.p12"), null);
+
+        assertEquals(200, resp.getStatus());
+        CertificateValidationResponse info = body(resp);
+        assertTrue(info.valid());
+        assertNotNull(info.subjectName());
+        assertFalse(info.subjectName().isEmpty());
+        assertNotNull(info.notAfter());
+        assertFalse(info.notAfter().isEmpty());
     }
 
     @Test
     void wrongPassword_returnsValidFalseWithErrorMessage() throws Exception {
-        mockMvc.perform(
-                        multipart("/api/v1/workflow/participant/validate-certificate")
-                                .file(p12Part("valid-test.p12"))
-                                .param("participantToken", TOKEN)
-                                .param("certType", "P12")
-                                .param("password", "wrongpassword"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.valid").value(false))
-                .andExpect(
-                        jsonPath("$.error")
-                                .value("Invalid certificate password or corrupt keystore file"));
+        Response resp =
+                controller.validateCertificate(
+                        TOKEN, "P12", "wrongpassword", p12Part("valid-test.p12"), null);
+
+        assertEquals(200, resp.getStatus());
+        CertificateValidationResponse info = body(resp);
+        assertFalse(info.valid());
+        assertEquals("Invalid certificate password or corrupt keystore file", info.error());
     }
 
     @Test
     void expiredP12_returnsValidFalseWithExpiryMessage() throws Exception {
-        mockMvc.perform(
-                        multipart("/api/v1/workflow/participant/validate-certificate")
-                                .file(p12Part("expired-test.p12"))
-                                .param("participantToken", TOKEN)
-                                .param("certType", "P12")
-                                .param("password", "testpass"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.valid").value(false))
-                .andExpect(
-                        jsonPath("$.error").value(org.hamcrest.Matchers.containsString("expired")));
+        Response resp =
+                controller.validateCertificate(
+                        TOKEN, "P12", "testpass", p12Part("expired-test.p12"), null);
+
+        assertEquals(200, resp.getStatus());
+        CertificateValidationResponse info = body(resp);
+        assertFalse(info.valid());
+        assertNotNull(info.error());
+        assertTrue(info.error().contains("expired"));
     }
 
     @Test
     void notYetValidP12_returnsValidFalseWithNotYetValidMessage() throws Exception {
-        mockMvc.perform(
-                        multipart("/api/v1/workflow/participant/validate-certificate")
-                                .file(p12Part("not-yet-valid-test.p12"))
-                                .param("participantToken", TOKEN)
-                                .param("certType", "P12")
-                                .param("password", "testpass"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.valid").value(false))
-                .andExpect(
-                        jsonPath("$.error")
-                                .value(org.hamcrest.Matchers.containsString("not yet valid")));
+        Response resp =
+                controller.validateCertificate(
+                        TOKEN, "P12", "testpass", p12Part("not-yet-valid-test.p12"), null);
+
+        assertEquals(200, resp.getStatus());
+        CertificateValidationResponse info = body(resp);
+        assertFalse(info.valid());
+        assertNotNull(info.error());
+        assertTrue(info.error().contains("not yet valid"));
     }
 
     @Test
     void validJks_returnsValidTrueWithSubjectName() throws Exception {
-        mockMvc.perform(
-                        multipart("/api/v1/workflow/participant/validate-certificate")
-                                .file(jksPart("valid-test.jks"))
-                                .param("participantToken", TOKEN)
-                                .param("certType", "JKS")
-                                .param("password", "jkspass"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.valid").value(true))
-                .andExpect(jsonPath("$.subjectName").isNotEmpty());
+        Response resp =
+                controller.validateCertificate(
+                        TOKEN, "JKS", "jkspass", null, jksPart("valid-test.jks"));
+
+        assertEquals(200, resp.getStatus());
+        CertificateValidationResponse info = body(resp);
+        assertTrue(info.valid());
+        assertNotNull(info.subjectName());
+        assertFalse(info.subjectName().isEmpty());
     }
 
     @Test
     void serverCertType_returnsValidTrueWithoutFileUpload() throws Exception {
-        mockMvc.perform(
-                        multipart("/api/v1/workflow/participant/validate-certificate")
-                                .param("participantToken", TOKEN)
-                                .param("certType", "SERVER"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.valid").value(true));
+        Response resp = controller.validateCertificate(TOKEN, "SERVER", null, null, null);
+
+        assertEquals(200, resp.getStatus());
+        assertTrue(body(resp).valid());
     }
 }

app/proprietary/src/test/java/stirling/software/proprietary/workflow/controller/WorkflowParticipantValidateCertificateTest.java

@@ -1,27 +1,29 @@
 package stirling.software.proprietary.workflow.controller;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.when;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
 import java.util.Date;
 import java.util.Optional;
 
+import org.jboss.resteasy.reactive.multipart.FileUpload;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.http.HttpStatus;
-import org.springframework.mock.web.MockMultipartFile;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.test.web.servlet.setup.MockMvcBuilders;
-import org.springframework.web.server.ResponseStatusException;
 
+import jakarta.ws.rs.WebApplicationException;
+import jakarta.ws.rs.core.Response;
+
+import stirling.software.common.testsupport.TestFileUploads;
 import stirling.software.proprietary.workflow.dto.CertificateInfo;
+import stirling.software.proprietary.workflow.dto.CertificateValidationResponse;
 import stirling.software.proprietary.workflow.model.WorkflowParticipant;
 import stirling.software.proprietary.workflow.repository.WorkflowParticipantRepository;
 import stirling.software.proprietary.workflow.service.CertificateSubmissionValidator;
@@ -30,6 +32,17 @@ import stirling.software.proprietary.workflow.service.WorkflowSessionService;
 
 import tools.jackson.databind.ObjectMapper;
 
+/**
+ * MIGRATION (Spring -> Quarkus): {@code WorkflowParticipantController} is a JAX-RS resource using
+ * field injection, so collaborators are wired by assigning the package-private {@code @Inject}
+ * fields directly (no constructor). The handler binds RESTEasy Reactive {@code FileUpload} args
+ * (stubbed via {@link TestFileUploads}) and returns {@link Response}.
+ *
+ * <p>Error semantics mirror the production handler: a missing file / invalid token throw {@code
+ * WebApplicationException} (asserted with {@code assertThrows}), while a validator failure is
+ * caught and returned as HTTP 200 with {@code valid:false}, so those are read off the {@code
+ * CertificateValidationResponse} entity.
+ */
 @ExtendWith(MockitoExtension.class)
 class WorkflowParticipantValidateCertificateTest {
 
@@ -38,21 +51,19 @@ class WorkflowParticipantValidateCertificateTest {
     @Mock private MetadataEncryptionService metadataEncryptionService;
     @Mock private CertificateSubmissionValidator certificateSubmissionValidator;
 
-    private MockMvc mockMvc;
+    private WorkflowParticipantController controller;
 
     private static final String VALID_TOKEN = "valid-share-token-abc123";
     private static final byte[] DUMMY_CERT = "dummy-cert-bytes".getBytes();
 
     @BeforeEach
     void setUp() {
-        WorkflowParticipantController controller =
-                new WorkflowParticipantController(
-                        workflowSessionService,
-                        participantRepository,
-                        new ObjectMapper(),
-                        metadataEncryptionService,
-                        certificateSubmissionValidator);
-        mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
+        controller = new WorkflowParticipantController();
+        controller.workflowSessionService = workflowSessionService;
+        controller.participantRepository = participantRepository;
+        controller.objectMapper = new ObjectMapper();
+        controller.metadataEncryptionService = metadataEncryptionService;
+        controller.certificateSubmissionValidator = certificateSubmissionValidator;
     }
 
     private WorkflowParticipant activeParticipant() {
@@ -61,10 +72,14 @@ class WorkflowParticipantValidateCertificateTest {
         return p;
     }
 
+    private static FileUpload p12Upload() {
+        return TestFileUploads.of(DUMMY_CERT, "cert.p12", "application/octet-stream");
+    }
+
     // ---- Happy path: valid cert ----
 
     @Test
-    void validCertificate_returns200WithValidTrue() throws Exception {
+    void validCertificate_returns200WithValidTrue() {
         when(participantRepository.findByShareToken(VALID_TOKEN))
                 .thenReturn(Optional.of(activeParticipant()));
 
@@ -78,82 +93,65 @@ class WorkflowParticipantValidateCertificateTest {
         when(certificateSubmissionValidator.validateAndExtractInfo(any(), eq("P12"), eq("secret")))
                 .thenReturn(info);
 
-        MockMultipartFile certFile =
-                new MockMultipartFile(
-                        "p12File", "cert.p12", "application/octet-stream", DUMMY_CERT);
+        Response resp =
+                controller.validateCertificate(VALID_TOKEN, "P12", "secret", p12Upload(), null);
 
-        mockMvc.perform(
-                        multipart("/api/v1/workflow/participant/validate-certificate")
-                                .file(certFile)
-                                .param("participantToken", VALID_TOKEN)
-                                .param("certType", "P12")
-                                .param("password", "secret"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.valid").value(true))
-                .andExpect(jsonPath("$.subjectName").value("Test Signer"));
+        assertEquals(200, resp.getStatus());
+        CertificateValidationResponse body = (CertificateValidationResponse) resp.getEntity();
+        assertTrue(body.valid());
+        assertEquals("Test Signer", body.subjectName());
     }
 
-    // ---- Bad password / invalid cert → validator throws 400, we return 200 valid:false ----
+    // ---- Bad password / invalid cert -> validator throws 400, we return 200 valid:false ----
 
     @Test
-    void invalidCertificate_returns200WithValidFalseAndErrorMessage() throws Exception {
+    void invalidCertificate_returns200WithValidFalseAndErrorMessage() {
         when(participantRepository.findByShareToken(VALID_TOKEN))
                 .thenReturn(Optional.of(activeParticipant()));
 
         when(certificateSubmissionValidator.validateAndExtractInfo(any(), any(), any()))
                 .thenThrow(
-                        new ResponseStatusException(
-                                HttpStatus.BAD_REQUEST,
-                                "Invalid certificate password or corrupt keystore file"));
+                        new WebApplicationException(
+                                "Invalid certificate password or corrupt keystore file",
+                                Response.Status.BAD_REQUEST));
 
-        MockMultipartFile certFile =
-                new MockMultipartFile(
-                        "p12File", "cert.p12", "application/octet-stream", DUMMY_CERT);
+        Response resp =
+                controller.validateCertificate(VALID_TOKEN, "P12", "wrong", p12Upload(), null);
 
-        mockMvc.perform(
-                        multipart("/api/v1/workflow/participant/validate-certificate")
-                                .file(certFile)
-                                .param("participantToken", VALID_TOKEN)
-                                .param("certType", "P12")
-                                .param("password", "wrong"))
-                .andExpect(status().isOk())
-                .andExpect(jsonPath("$.valid").value(false))
-                .andExpect(
-                        jsonPath("$.error")
-                                .value("Invalid certificate password or corrupt keystore file"));
+        assertEquals(200, resp.getStatus());
+        CertificateValidationResponse body = (CertificateValidationResponse) resp.getEntity();
+        assertFalse(body.valid());
+        assertEquals("Invalid certificate password or corrupt keystore file", body.error());
     }
 
-    // ---- No file → 400 bad request ----
+    // ---- No file -> 400 bad request ----
 
     @Test
-    void missingCertFile_returns400() throws Exception {
+    void missingCertFile_returns400() {
         when(participantRepository.findByShareToken(VALID_TOKEN))
                 .thenReturn(Optional.of(activeParticipant()));
 
-        mockMvc.perform(
-                        multipart("/api/v1/workflow/participant/validate-certificate")
-                                .param("participantToken", VALID_TOKEN)
-                                .param("certType", "P12")
-                                .param("password", "pass"))
-                .andExpect(status().isBadRequest());
+        WebApplicationException ex =
+                assertThrows(
+                        WebApplicationException.class,
+                        () ->
+                                controller.validateCertificate(
+                                        VALID_TOKEN, "P12", "pass", null, null));
+        assertEquals(400, ex.getResponse().getStatus());
     }
 
-    // ---- Invalid / expired token → 403 ----
+    // ---- Invalid / expired token -> 403 ----
 
     @Test
-    void invalidToken_returns403() throws Exception {
+    void invalidToken_returns403() {
         when(participantRepository.findByShareToken("bad-token")).thenReturn(Optional.empty());
 
-        MockMultipartFile certFile =
-                new MockMultipartFile(
-                        "p12File", "cert.p12", "application/octet-stream", DUMMY_CERT);
-
-        mockMvc.perform(
-                        multipart("/api/v1/workflow/participant/validate-certificate")
-                                .file(certFile)
-                                .param("participantToken", "bad-token")
-                                .param("certType", "P12")
-                                .param("password", "pass"))
-                .andExpect(status().isForbidden());
+        WebApplicationException ex =
+                assertThrows(
+                        WebApplicationException.class,
+                        () ->
+                                controller.validateCertificate(
+                                        "bad-token", "P12", "pass", p12Upload(), null));
+        assertEquals(403, ex.getResponse().getStatus());
     }
 }