Mirrors/Stirling-PDF
Mirrors/Stirling-PDF
1
0
Fork 0
mirror of https://github.com/Frooodle/Stirling-PDF.git synced 2025-08-02 13:48:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge 24d29190b2 into a5d219ed05

Browse Source
This commit is contained in:
stirlingbot[bot] 2025-08-01 16:24:37 +00:00 committed by GitHub
commit 6f17b42e98
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
30 changed files with 1096 additions and 869 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
app/common/src/test/java/stirling/software/common/annotations/AutoJobPostMappingIntegrationTest.java
View File

@ -7,24 +7,19 @@ import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean; import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times; import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
import org.junit.jupiter.api.BeforeEach;
import java.util.Arrays;
import java.util.function.Supplier; import java.util.function.Supplier;
import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.ProceedingJoinPoint;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor; import org.mockito.ArgumentCaptor;
import org.mockito.Captor; import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
@ -45,62 +40,44 @@ class AutoJobPostMappingIntegrationTest {
private AutoJobAspect autoJobAspect; private AutoJobAspect autoJobAspect;
@Mock @Mock private JobExecutorService jobExecutorService;
private JobExecutorService jobExecutorService;
@Mock @Mock private HttpServletRequest request;
private HttpServletRequest request;
@Mock @Mock private FileOrUploadService fileOrUploadService;
private FileOrUploadService fileOrUploadService;
@Mock @Mock private FileStorage fileStorage;
private FileStorage fileStorage;
@Mock private ResourceMonitor resourceMonitor;
@Mock @Mock private JobQueue jobQueue;
private ResourceMonitor resourceMonitor;
@Mock
private JobQueue jobQueue;
@BeforeEach @BeforeEach
void setUp() { void setUp() {
autoJobAspect = new AutoJobAspect( autoJobAspect =
jobExecutorService, new AutoJobAspect(jobExecutorService, request, fileOrUploadService, fileStorage);
request,
fileOrUploadService,
fileStorage
);
} }
@Mock @Mock private ProceedingJoinPoint joinPoint;
private ProceedingJoinPoint joinPoint;
@Mock @Mock private AutoJobPostMapping autoJobPostMapping;
private AutoJobPostMapping autoJobPostMapping;
@Captor @Captor private ArgumentCaptor<Supplier<Object>> workCaptor;
private ArgumentCaptor<Supplier<Object>> workCaptor;
@Captor @Captor private ArgumentCaptor<Boolean> asyncCaptor;
private ArgumentCaptor<Boolean> asyncCaptor;
@Captor @Captor private ArgumentCaptor<Long> timeoutCaptor;
private ArgumentCaptor<Long> timeoutCaptor;
@Captor @Captor private ArgumentCaptor<Boolean> queueableCaptor;
private ArgumentCaptor<Boolean> queueableCaptor;
@Captor @Captor private ArgumentCaptor<Integer> resourceWeightCaptor;
private ArgumentCaptor<Integer> resourceWeightCaptor;
@Test @Test
void shouldExecuteWithCustomParameters() throws Throwable { void shouldExecuteWithCustomParameters() throws Throwable {
// Given // Given
PDFFile pdfFile = new PDFFile(); PDFFile pdfFile = new PDFFile();
pdfFile.setFileId("test-file-id"); pdfFile.setFileId("test-file-id");
Object[] args = new Object[] { pdfFile }; Object[] args = new Object[] {pdfFile};
when(joinPoint.getArgs()).thenReturn(args); when(joinPoint.getArgs()).thenReturn(args);
when(request.getParameter("async")).thenReturn("true"); when(request.getParameter("async")).thenReturn("true");
@ -113,9 +90,8 @@ class AutoJobPostMappingIntegrationTest {
MultipartFile mockFile = mock(MultipartFile.class); MultipartFile mockFile = mock(MultipartFile.class);
when(fileStorage.retrieveFile("test-file-id")).thenReturn(mockFile); when(fileStorage.retrieveFile("test-file-id")).thenReturn(mockFile);
when(jobExecutorService.runJobGeneric( when(jobExecutorService.runJobGeneric(
anyBoolean(), any(Supplier.class), anyLong(), anyBoolean(), anyInt())) anyBoolean(), any(Supplier.class), anyLong(), anyBoolean(), anyInt()))
.thenReturn(ResponseEntity.ok("success")); .thenReturn(ResponseEntity.ok("success"));
// When // When
@ -124,12 +100,13 @@ class AutoJobPostMappingIntegrationTest {
// Then // Then
assertEquals(ResponseEntity.ok("success"), result); assertEquals(ResponseEntity.ok("success"), result);
verify(jobExecutorService).runJobGeneric( verify(jobExecutorService)
asyncCaptor.capture(), .runJobGeneric(
workCaptor.capture(), asyncCaptor.capture(),
timeoutCaptor.capture(), workCaptor.capture(),
queueableCaptor.capture(), timeoutCaptor.capture(),
resourceWeightCaptor.capture()); queueableCaptor.capture(),
resourceWeightCaptor.capture());
assertTrue(asyncCaptor.getValue(), "Async should be true"); assertTrue(asyncCaptor.getValue(), "Async should be true");
assertEquals(60000L, timeoutCaptor.getValue(), "Timeout should be 60000ms"); assertEquals(60000L, timeoutCaptor.getValue(), "Timeout should be 60000ms");
@ -158,11 +135,12 @@ class AutoJobPostMappingIntegrationTest {
// Mock jobExecutorService to execute the work immediately // Mock jobExecutorService to execute the work immediately
when(jobExecutorService.runJobGeneric( when(jobExecutorService.runJobGeneric(
anyBoolean(), any(Supplier.class), anyLong(), anyBoolean(), anyInt())) anyBoolean(), any(Supplier.class), anyLong(), anyBoolean(), anyInt()))
.thenAnswer(invocation -> { .thenAnswer(
Supplier<Object> work = invocation.getArgument(1); invocation -> {
return work.get(); Supplier<Object> work = invocation.getArgument(1);
}); return work.get();
});
// When // When
Object result = autoJobAspect.wrapWithJobExecution(joinPoint, autoJobPostMapping); Object result = autoJobAspect.wrapWithJobExecution(joinPoint, autoJobPostMapping);
@ -179,7 +157,7 @@ class AutoJobPostMappingIntegrationTest {
// Given // Given
PDFFile pdfFile = new PDFFile(); PDFFile pdfFile = new PDFFile();
pdfFile.setFileInput(mock(MultipartFile.class)); pdfFile.setFileInput(mock(MultipartFile.class));
Object[] args = new Object[] { pdfFile }; Object[] args = new Object[] {pdfFile};
when(joinPoint.getArgs()).thenReturn(args); when(joinPoint.getArgs()).thenReturn(args);
when(request.getParameter("async")).thenReturn("true"); when(request.getParameter("async")).thenReturn("true");
@ -190,14 +168,16 @@ class AutoJobPostMappingIntegrationTest {
// Mock job executor to return a successful response // Mock job executor to return a successful response
when(jobExecutorService.runJobGeneric( when(jobExecutorService.runJobGeneric(
anyBoolean(), any(Supplier.class), anyLong(), anyBoolean(), anyInt())) anyBoolean(), any(Supplier.class), anyLong(), anyBoolean(), anyInt()))
.thenReturn(ResponseEntity.ok("success")); .thenReturn(ResponseEntity.ok("success"));
// When // When
autoJobAspect.wrapWithJobExecution(joinPoint, autoJobPostMapping); autoJobAspect.wrapWithJobExecution(joinPoint, autoJobPostMapping);
// Then // Then
assertEquals("stored-file-id", pdfFile.getFileId(), assertEquals(
"stored-file-id",
pdfFile.getFileId(),
"FileId should be set to the stored file id"); "FileId should be set to the stored file id");
assertNotNull(pdfFile.getFileInput(), "FileInput should be replaced with persistent file"); assertNotNull(pdfFile.getFileInput(), "FileInput should be replaced with persistent file");

27
app/common/src/test/java/stirling/software/common/service/FileStorageTest.java
View File

@ -1,10 +1,9 @@
package stirling.software.common.service; package stirling.software.common.service;
import static org.junit.jupiter.api.Assertions.*; import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import static org.mockito.AdditionalAnswers.*; import static org.mockito.AdditionalAnswers.*;
import static org.mockito.Mockito.*;
import java.io.ByteArrayInputStream;
import java.io.IOException; import java.io.IOException;
import java.nio.file.Files; import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
@ -21,14 +20,11 @@ import org.springframework.web.multipart.MultipartFile;
class FileStorageTest { class FileStorageTest {
@TempDir @TempDir Path tempDir;
Path tempDir;
@Mock @Mock private FileOrUploadService fileOrUploadService;
private FileOrUploadService fileOrUploadService;
@InjectMocks @InjectMocks private FileStorage fileStorage;
private FileStorage fileStorage;
private MultipartFile mockFile; private MultipartFile mockFile;
@ -50,11 +46,14 @@ class FileStorageTest {
when(mockFile.getBytes()).thenReturn(fileContent); when(mockFile.getBytes()).thenReturn(fileContent);
// Set up mock to handle transferTo by writing the file // Set up mock to handle transferTo by writing the file
doAnswer(invocation -> { doAnswer(
java.io.File file = invocation.getArgument(0); invocation -> {
Files.write(file.toPath(), fileContent); java.io.File file = invocation.getArgument(0);
return null; Files.write(file.toPath(), fileContent);
}).when(mockFile).transferTo(any(java.io.File.class)); return null;
})
.when(mockFile)
.transferTo(any(java.io.File.class));
// Act // Act
String fileId = fileStorage.storeFile(mockFile); String fileId = fileStorage.storeFile(mockFile);
@ -90,7 +89,7 @@ class FileStorageTest {
MultipartFile expectedFile = mock(MultipartFile.class); MultipartFile expectedFile = mock(MultipartFile.class);
when(fileOrUploadService.toMockMultipartFile(eq(fileId), eq(fileContent))) when(fileOrUploadService.toMockMultipartFile(eq(fileId), eq(fileContent)))
.thenReturn(expectedFile); .thenReturn(expectedFile);
// Act // Act
MultipartFile result = fileStorage.retrieveFile(fileId); MultipartFile result = fileStorage.retrieveFile(fileId);

84
app/common/src/test/java/stirling/software/common/service/JobExecutorServiceTest.java
View File

@ -4,14 +4,9 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
@ -30,11 +25,9 @@ import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.test.util.ReflectionTestUtils;
import jakarta.servlet.http.HttpServletRequest; import jakarta.servlet.http.HttpServletRequest;
import stirling.software.common.model.job.JobProgress;
import stirling.software.common.model.job.JobResponse; import stirling.software.common.model.job.JobResponse;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
@ -42,36 +35,31 @@ class JobExecutorServiceTest {
private JobExecutorService jobExecutorService; private JobExecutorService jobExecutorService;
@Mock @Mock private TaskManager taskManager;
private TaskManager taskManager;
@Mock @Mock private FileStorage fileStorage;
private FileStorage fileStorage;
@Mock @Mock private HttpServletRequest request;
private HttpServletRequest request;
@Mock @Mock private ResourceMonitor resourceMonitor;
private ResourceMonitor resourceMonitor;
@Mock @Mock private JobQueue jobQueue;
private JobQueue jobQueue;
@Captor @Captor private ArgumentCaptor<String> jobIdCaptor;
private ArgumentCaptor<String> jobIdCaptor;
@BeforeEach @BeforeEach
void setUp() { void setUp() {
// Initialize the service manually with all its dependencies // Initialize the service manually with all its dependencies
jobExecutorService = new JobExecutorService( jobExecutorService =
taskManager, new JobExecutorService(
fileStorage, taskManager,
request, fileStorage,
resourceMonitor, request,
jobQueue, resourceMonitor,
30000L, // asyncRequestTimeoutMs jobQueue,
"30m" // sessionTimeout 30000L, // asyncRequestTimeoutMs
); "30m" // sessionTimeout
);
} }
@Test @Test
@ -109,13 +97,13 @@ class JobExecutorServiceTest {
verify(taskManager).createTask(jobIdCaptor.capture()); verify(taskManager).createTask(jobIdCaptor.capture());
} }
@Test @Test
void shouldHandleSyncJobError() { void shouldHandleSyncJobError() {
// Given // Given
Supplier<Object> work = () -> { Supplier<Object> work =
throw new RuntimeException("Test error"); () -> {
}; throw new RuntimeException("Test error");
};
// When // When
ResponseEntity<?> response = jobExecutorService.runJobGeneric(false, work); ResponseEntity<?> response = jobExecutorService.runJobGeneric(false, work);
@ -141,8 +129,7 @@ class JobExecutorServiceTest {
when(jobQueue.queueJob(anyString(), eq(80), any(), anyLong())).thenReturn(future); when(jobQueue.queueJob(anyString(), eq(80), any(), anyLong())).thenReturn(future);
// When // When
ResponseEntity<?> response = jobExecutorService.runJobGeneric( ResponseEntity<?> response = jobExecutorService.runJobGeneric(true, work, 5000, true, 80);
true, work, 5000, true, 80);
// Then // Then
assertEquals(HttpStatus.OK, response.getStatusCode()); assertEquals(HttpStatus.OK, response.getStatusCode());
@ -160,8 +147,9 @@ class JobExecutorServiceTest {
long customTimeout = 60000L; long customTimeout = 60000L;
// Use reflection to access the private executeWithTimeout method // Use reflection to access the private executeWithTimeout method
java.lang.reflect.Method executeMethod = JobExecutorService.class java.lang.reflect.Method executeMethod =
.getDeclaredMethod("executeWithTimeout", Supplier.class, long.class); JobExecutorService.class.getDeclaredMethod(
"executeWithTimeout", Supplier.class, long.class);
executeMethod.setAccessible(true); executeMethod.setAccessible(true);
// Create a spy on the JobExecutorService to verify method calls // Create a spy on the JobExecutorService to verify method calls
@ -177,19 +165,21 @@ class JobExecutorServiceTest {
@Test @Test
void shouldHandleTimeout() throws Exception { void shouldHandleTimeout() throws Exception {
// Given // Given
Supplier<Object> work = () -> { Supplier<Object> work =
try { () -> {
Thread.sleep(100); // Simulate long-running job try {
return "test-result"; Thread.sleep(100); // Simulate long-running job
} catch (InterruptedException e) { return "test-result";
Thread.currentThread().interrupt(); } catch (InterruptedException e) {
throw new RuntimeException(e); Thread.currentThread().interrupt();
} throw new RuntimeException(e);
}; }
};
// Use reflection to access the private executeWithTimeout method // Use reflection to access the private executeWithTimeout method
java.lang.reflect.Method executeMethod = JobExecutorService.class java.lang.reflect.Method executeMethod =
.getDeclaredMethod("executeWithTimeout", Supplier.class, long.class); JobExecutorService.class.getDeclaredMethod(
"executeWithTimeout", Supplier.class, long.class);
executeMethod.setAccessible(true); executeMethod.setAccessible(true);
// When/Then // When/Then

15
app/common/src/test/java/stirling/software/common/service/JobQueueTest.java
View File

@ -1,10 +1,8 @@
package stirling.software.common.service; package stirling.software.common.service;
import static org.junit.jupiter.api.Assertions.*; import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.lenient; import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
import java.util.Map; import java.util.Map;
@ -17,7 +15,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoExtension;
import stirling.software.common.model.job.JobProgress;
import stirling.software.common.service.ResourceMonitor.ResourceStatus; import stirling.software.common.service.ResourceMonitor.ResourceStatus;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
@ -25,16 +22,17 @@ class JobQueueTest {
private JobQueue jobQueue; private JobQueue jobQueue;
@Mock @Mock private ResourceMonitor resourceMonitor;
private ResourceMonitor resourceMonitor;
private final AtomicReference<ResourceStatus> statusRef =
private final AtomicReference<ResourceStatus> statusRef = new AtomicReference<>(ResourceStatus.OK); new AtomicReference<>(ResourceStatus.OK);
@BeforeEach @BeforeEach
void setUp() { void setUp() {
// Mark stubbing as lenient to avoid UnnecessaryStubbingException // Mark stubbing as lenient to avoid UnnecessaryStubbingException
lenient().when(resourceMonitor.calculateDynamicQueueCapacity(anyInt(), anyInt())).thenReturn(10); lenient()
.when(resourceMonitor.calculateDynamicQueueCapacity(anyInt(), anyInt()))
.thenReturn(10);
lenient().when(resourceMonitor.getCurrentStatus()).thenReturn(statusRef); lenient().when(resourceMonitor.getCurrentStatus()).thenReturn(statusRef);
// Initialize JobQueue with mocked ResourceMonitor // Initialize JobQueue with mocked ResourceMonitor
@ -50,7 +48,6 @@ class JobQueueTest {
jobQueue.queueJob(jobId, resourceWeight, work, timeoutMs); jobQueue.queueJob(jobId, resourceWeight, work, timeoutMs);
assertTrue(jobQueue.isJobQueued(jobId)); assertTrue(jobQueue.isJobQueued(jobId));
assertEquals(1, jobQueue.getTotalQueuedJobs()); assertEquals(1, jobQueue.getTotalQueuedJobs());
} }

49
app/common/src/test/java/stirling/software/common/service/ResourceMonitorTest.java
View File

@ -1,14 +1,10 @@
package stirling.software.common.service; package stirling.software.common.service;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.lang.management.MemoryMXBean; import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
import java.lang.management.OperatingSystemMXBean; import java.lang.management.OperatingSystemMXBean;
import java.time.Instant; import java.time.Instant;
import java.util.concurrent.atomic.AtomicReference; import java.util.concurrent.atomic.AtomicReference;
@ -30,20 +26,19 @@ import stirling.software.common.service.ResourceMonitor.ResourceStatus;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
class ResourceMonitorTest { class ResourceMonitorTest {
@InjectMocks @InjectMocks private ResourceMonitor resourceMonitor;
private ResourceMonitor resourceMonitor;
@Mock @Mock private OperatingSystemMXBean osMXBean;
private OperatingSystemMXBean osMXBean;
@Mock @Mock private MemoryMXBean memoryMXBean;
private MemoryMXBean memoryMXBean;
@Spy @Spy
private AtomicReference<ResourceStatus> currentStatus = new AtomicReference<>(ResourceStatus.OK); private AtomicReference<ResourceStatus> currentStatus =
new AtomicReference<>(ResourceStatus.OK);
@Spy @Spy
private AtomicReference<ResourceMetrics> latestMetrics = new AtomicReference<>(new ResourceMetrics()); private AtomicReference<ResourceMetrics> latestMetrics =
new AtomicReference<>(new ResourceMetrics());
@BeforeEach @BeforeEach
void setUp() { void setUp() {
@ -92,23 +87,26 @@ class ResourceMonitorTest {
assertEquals(3, capacity, "With CRITICAL status, capacity should be reduced to 30%"); assertEquals(3, capacity, "With CRITICAL status, capacity should be reduced to 30%");
// Test minimum capacity enforcement // Test minimum capacity enforcement
assertEquals(minCapacity, resourceMonitor.calculateDynamicQueueCapacity(1, minCapacity), assertEquals(
minCapacity,
resourceMonitor.calculateDynamicQueueCapacity(1, minCapacity),
"Should never go below minimum capacity"); "Should never go below minimum capacity");
} }
@ParameterizedTest @ParameterizedTest
@CsvSource({ @CsvSource({
"10, OK, false", // Light job, OK status "10, OK, false", // Light job, OK status
"10, WARNING, false", // Light job, WARNING status "10, WARNING, false", // Light job, WARNING status
"10, CRITICAL, true", // Light job, CRITICAL status "10, CRITICAL, true", // Light job, CRITICAL status
"30, OK, false", // Medium job, OK status "30, OK, false", // Medium job, OK status
"30, WARNING, true", // Medium job, WARNING status "30, WARNING, true", // Medium job, WARNING status
"30, CRITICAL, true", // Medium job, CRITICAL status "30, CRITICAL, true", // Medium job, CRITICAL status
"80, OK, true", // Heavy job, OK status "80, OK, true", // Heavy job, OK status
"80, WARNING, true", // Heavy job, WARNING status "80, WARNING, true", // Heavy job, WARNING status
"80, CRITICAL, true" // Heavy job, CRITICAL status "80, CRITICAL, true" // Heavy job, CRITICAL status
}) })
void shouldQueueJobBasedOnWeightAndStatus(int weight, ResourceStatus status, boolean shouldQueue) { void shouldQueueJobBasedOnWeightAndStatus(
int weight, ResourceStatus status, boolean shouldQueue) {
// Given // Given
currentStatus.set(status); currentStatus.set(status);
@ -116,8 +114,11 @@ class ResourceMonitorTest {
boolean result = resourceMonitor.shouldQueueJob(weight); boolean result = resourceMonitor.shouldQueueJob(weight);
// Then // Then
assertEquals(shouldQueue, result, assertEquals(
String.format("For weight %d and status %s, shouldQueue should be %s", shouldQueue,
result,
String.format(
"For weight %d and status %s, shouldQueue should be %s",
weight, status, shouldQueue)); weight, status, shouldQueue));
} }
@ -131,7 +132,9 @@ class ResourceMonitorTest {
ResourceMetrics freshMetrics = new ResourceMetrics(0.5, 0.5, 1024, 2048, 4096, now); ResourceMetrics freshMetrics = new ResourceMetrics(0.5, 0.5, 1024, 2048, 4096, now);
// When/Then // When/Then
assertTrue(staleMetrics.isStale(5000), "Metrics from 6 seconds ago should be stale with 5s threshold"); assertTrue(
staleMetrics.isStale(5000),
"Metrics from 6 seconds ago should be stale with 5s threshold");
assertFalse(freshMetrics.isStale(5000), "Fresh metrics should not be stale"); assertFalse(freshMetrics.isStale(5000), "Fresh metrics should not be stale");
} }
} }

23
app/common/src/test/java/stirling/software/common/service/TaskManagerTest.java
View File

@ -6,7 +6,6 @@ import static org.mockito.Mockito.*;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.util.Map; import java.util.Map;
import java.util.UUID; import java.util.UUID;
import java.util.concurrent.TimeUnit;
import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
@ -22,11 +21,9 @@ import stirling.software.common.model.job.ResultFile;
class TaskManagerTest { class TaskManagerTest {
@Mock @Mock private FileStorage fileStorage;
private FileStorage fileStorage;
@InjectMocks @InjectMocks private TaskManager taskManager;
private TaskManager taskManager;
private AutoCloseable closeable; private AutoCloseable closeable;
@ -234,18 +231,20 @@ class TaskManagerTest {
ReflectionTestUtils.setField(oldJob, "complete", true); ReflectionTestUtils.setField(oldJob, "complete", true);
// Create a ResultFile and set it using the new approach // Create a ResultFile and set it using the new approach
ResultFile resultFile = ResultFile.builder() ResultFile resultFile =
.fileId("file-id") ResultFile.builder()
.fileName("test.pdf") .fileId("file-id")
.contentType("application/pdf") .fileName("test.pdf")
.fileSize(1024L) .contentType("application/pdf")
.build(); .fileSize(1024L)
.build();
ReflectionTestUtils.setField(oldJob, "resultFiles", java.util.List.of(resultFile)); ReflectionTestUtils.setField(oldJob, "resultFiles", java.util.List.of(resultFile));
when(fileStorage.deleteFile("file-id")).thenReturn(true); when(fileStorage.deleteFile("file-id")).thenReturn(true);
// Obtain access to the private jobResults map // Obtain access to the private jobResults map
Map<String, JobResult> jobResultsMap = (Map<String, JobResult>) ReflectionTestUtils.getField(taskManager, "jobResults"); Map<String, JobResult> jobResultsMap =
(Map<String, JobResult>) ReflectionTestUtils.getField(taskManager, "jobResults");
// 3. Create an active job // 3. Create an active job
String activeJobId = "active-job"; String activeJobId = "active-job";

349
app/common/src/test/java/stirling/software/common/service/TempFileCleanupServiceTest.java
View File

@ -12,7 +12,6 @@ import java.nio.file.Path;
import java.nio.file.attribute.FileTime; import java.nio.file.attribute.FileTime;
import java.util.HashSet; import java.util.HashSet;
import java.util.Set; import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer; import java.util.function.Consumer;
import java.util.stream.Stream; import java.util.stream.Stream;
@ -30,31 +29,22 @@ import stirling.software.common.model.ApplicationProperties;
import stirling.software.common.util.TempFileManager; import stirling.software.common.util.TempFileManager;
import stirling.software.common.util.TempFileRegistry; import stirling.software.common.util.TempFileRegistry;
/** /** Tests for the TempFileCleanupService, focusing on its pattern-matching and cleanup logic. */
* Tests for the TempFileCleanupService, focusing on its pattern-matching and cleanup logic.
*/
public class TempFileCleanupServiceTest { public class TempFileCleanupServiceTest {
@TempDir @TempDir Path tempDir;
Path tempDir;
@Mock @Mock private TempFileRegistry registry;
private TempFileRegistry registry;
@Mock @Mock private TempFileManager tempFileManager;
private TempFileManager tempFileManager;
@Mock @Mock private ApplicationProperties applicationProperties;
private ApplicationProperties applicationProperties;
@Mock @Mock private ApplicationProperties.System system;
private ApplicationProperties.System system;
@Mock @Mock private ApplicationProperties.TempFileManagement tempFileManagement;
private ApplicationProperties.TempFileManagement tempFileManagement;
@InjectMocks @InjectMocks private TempFileCleanupService cleanupService;
private TempFileCleanupService cleanupService;
private Path systemTempDir; private Path systemTempDir;
private Path customTempDir; private Path customTempDir;
@ -124,7 +114,8 @@ public class TempFileCleanupServiceTest {
// Files that should be preserved // Files that should be preserved
Path jettyFile1 = Files.createFile(systemTempDir.resolve("jetty-123.tmp")); Path jettyFile1 = Files.createFile(systemTempDir.resolve("jetty-123.tmp"));
Path jettyFile2 = Files.createFile(systemTempDir.resolve("something-with-jetty-inside.tmp")); Path jettyFile2 =
Files.createFile(systemTempDir.resolve("something-with-jetty-inside.tmp"));
Path regularFile = Files.createFile(systemTempDir.resolve("important.txt")); Path regularFile = Files.createFile(systemTempDir.resolve("important.txt"));
// Create a nested directory with temp files // Create a nested directory with temp files
@ -143,19 +134,29 @@ public class TempFileCleanupServiceTest {
// Use MockedStatic to mock Files operations // Use MockedStatic to mock Files operations
try (MockedStatic<Files> mockedFiles = mockStatic(Files.class)) { try (MockedStatic<Files> mockedFiles = mockStatic(Files.class)) {
// Mock Files.list for each directory we'll process // Mock Files.list for each directory we'll process
mockedFiles.when(() -> Files.list(eq(systemTempDir))) mockedFiles
.thenReturn(Stream.of( .when(() -> Files.list(eq(systemTempDir)))
ourTempFile1, ourTempFile2, oldTempFile, sysTempFile1, .thenReturn(
jettyFile1, jettyFile2, regularFile, emptyFile, nestedDir)); Stream.of(
ourTempFile1,
ourTempFile2,
oldTempFile,
sysTempFile1,
jettyFile1,
jettyFile2,
regularFile,
emptyFile,
nestedDir));
mockedFiles.when(() -> Files.list(eq(customTempDir))) mockedFiles
.when(() -> Files.list(eq(customTempDir)))
.thenReturn(Stream.of(ourTempFile3, ourTempFile4, sysTempFile2, sysTempFile3)); .thenReturn(Stream.of(ourTempFile3, ourTempFile4, sysTempFile2, sysTempFile3));
mockedFiles.when(() -> Files.list(eq(libreOfficeTempDir))) mockedFiles
.when(() -> Files.list(eq(libreOfficeTempDir)))
.thenReturn(Stream.of(ourTempFile5)); .thenReturn(Stream.of(ourTempFile5));
mockedFiles.when(() -> Files.list(eq(nestedDir))) mockedFiles.when(() -> Files.list(eq(nestedDir))).thenReturn(Stream.of(nestedTempFile));
.thenReturn(Stream.of(nestedTempFile));
// Configure Files.isDirectory for each path // Configure Files.isDirectory for each path
mockedFiles.when(() -> Files.isDirectory(eq(nestedDir))).thenReturn(true); mockedFiles.when(() -> Files.isDirectory(eq(nestedDir))).thenReturn(true);
@ -165,48 +166,59 @@ public class TempFileCleanupServiceTest {
mockedFiles.when(() -> Files.exists(any(Path.class))).thenReturn(true); mockedFiles.when(() -> Files.exists(any(Path.class))).thenReturn(true);
// Configure Files.getLastModifiedTime to return different times based on file names // Configure Files.getLastModifiedTime to return different times based on file names
mockedFiles.when(() -> Files.getLastModifiedTime(any(Path.class))) mockedFiles
.thenAnswer(invocation -> { .when(() -> Files.getLastModifiedTime(any(Path.class)))
Path path = invocation.getArgument(0); .thenAnswer(
String fileName = path.getFileName().toString(); invocation -> {
Path path = invocation.getArgument(0);
String fileName = path.getFileName().toString();
// For files with "old" in the name, return a timestamp older than maxAgeMillis // For files with "old" in the name, return a timestamp older than
if (fileName.contains("old")) { // maxAgeMillis
return FileTime.fromMillis(System.currentTimeMillis() - 5000000); if (fileName.contains("old")) {
} return FileTime.fromMillis(
// For empty.tmp file, return a timestamp older than 5 minutes (for empty file test) System.currentTimeMillis() - 5000000);
else if (fileName.equals("empty.tmp")) { }
return FileTime.fromMillis(System.currentTimeMillis() - 6 * 60 * 1000); // For empty.tmp file, return a timestamp older than 5 minutes (for
} // empty file test)
// For all other files, return a recent timestamp else if (fileName.equals("empty.tmp")) {
else { return FileTime.fromMillis(
return FileTime.fromMillis(System.currentTimeMillis() - 60000); // 1 minute ago System.currentTimeMillis() - 6 * 60 * 1000);
} }
}); // For all other files, return a recent timestamp
else {
return FileTime.fromMillis(
System.currentTimeMillis() - 60000); // 1 minute ago
}
});
// Configure Files.size to return different sizes based on file names // Configure Files.size to return different sizes based on file names
mockedFiles.when(() -> Files.size(any(Path.class))) mockedFiles
.thenAnswer(invocation -> { .when(() -> Files.size(any(Path.class)))
Path path = invocation.getArgument(0); .thenAnswer(
String fileName = path.getFileName().toString(); invocation -> {
Path path = invocation.getArgument(0);
String fileName = path.getFileName().toString();
// Return 0 bytes for the empty file // Return 0 bytes for the empty file
if (fileName.equals("empty.tmp")) { if (fileName.equals("empty.tmp")) {
return 0L; return 0L;
} }
// Return normal size for all other files // Return normal size for all other files
else { else {
return 1024L; // 1 KB return 1024L; // 1 KB
} }
}); });
// For deleteIfExists, track which files would be deleted // For deleteIfExists, track which files would be deleted
mockedFiles.when(() -> Files.deleteIfExists(any(Path.class))) mockedFiles
.thenAnswer(invocation -> { .when(() -> Files.deleteIfExists(any(Path.class)))
Path path = invocation.getArgument(0); .thenAnswer(
deletedFiles.add(path); invocation -> {
return true; Path path = invocation.getArgument(0);
}); deletedFiles.add(path);
return true;
});
// Act - set containerMode to false for this test // Act - set containerMode to false for this test
invokeCleanupDirectoryStreaming(systemTempDir, false, 0, 3600000); invokeCleanupDirectoryStreaming(systemTempDir, false, 0, 3600000);
@ -218,20 +230,33 @@ public class TempFileCleanupServiceTest {
assertTrue(deletedFiles.contains(emptyFile), "Empty file should be deleted"); assertTrue(deletedFiles.contains(emptyFile), "Empty file should be deleted");
// Regular temp files should not be deleted because they're too new // Regular temp files should not be deleted because they're too new
assertFalse(deletedFiles.contains(ourTempFile1), "Recent temp file should be preserved"); assertFalse(
assertFalse(deletedFiles.contains(ourTempFile2), "Recent temp file should be preserved"); deletedFiles.contains(ourTempFile1), "Recent temp file should be preserved");
assertFalse(deletedFiles.contains(ourTempFile3), "Recent temp file should be preserved"); assertFalse(
assertFalse(deletedFiles.contains(ourTempFile4), "Recent temp file should be preserved"); deletedFiles.contains(ourTempFile2), "Recent temp file should be preserved");
assertFalse(deletedFiles.contains(ourTempFile5), "Recent temp file should be preserved"); assertFalse(
deletedFiles.contains(ourTempFile3), "Recent temp file should be preserved");
assertFalse(
deletedFiles.contains(ourTempFile4), "Recent temp file should be preserved");
assertFalse(
deletedFiles.contains(ourTempFile5), "Recent temp file should be preserved");
// System temp files should not be deleted in non-container mode // System temp files should not be deleted in non-container mode
assertFalse(deletedFiles.contains(sysTempFile1), "System temp file should be preserved in non-container mode"); assertFalse(
assertFalse(deletedFiles.contains(sysTempFile2), "System temp file should be preserved in non-container mode"); deletedFiles.contains(sysTempFile1),
assertFalse(deletedFiles.contains(sysTempFile3), "System temp file should be preserved in non-container mode"); "System temp file should be preserved in non-container mode");
assertFalse(
deletedFiles.contains(sysTempFile2),
"System temp file should be preserved in non-container mode");
assertFalse(
deletedFiles.contains(sysTempFile3),
"System temp file should be preserved in non-container mode");
// Jetty files and regular files should never be deleted // Jetty files and regular files should never be deleted
assertFalse(deletedFiles.contains(jettyFile1), "Jetty file should be preserved"); assertFalse(deletedFiles.contains(jettyFile1), "Jetty file should be preserved");
assertFalse(deletedFiles.contains(jettyFile2), "File with jetty in name should be preserved"); assertFalse(
deletedFiles.contains(jettyFile2),
"File with jetty in name should be preserved");
assertFalse(deletedFiles.contains(regularFile), "Regular file should be preserved"); assertFalse(deletedFiles.contains(regularFile), "Regular file should be preserved");
} }
} }
@ -252,7 +277,8 @@ public class TempFileCleanupServiceTest {
// Use MockedStatic to mock Files operations // Use MockedStatic to mock Files operations
try (MockedStatic<Files> mockedFiles = mockStatic(Files.class)) { try (MockedStatic<Files> mockedFiles = mockStatic(Files.class)) {
// Mock Files.list for systemTempDir // Mock Files.list for systemTempDir
mockedFiles.when(() -> Files.list(eq(systemTempDir))) mockedFiles
.when(() -> Files.list(eq(systemTempDir)))
.thenReturn(Stream.of(ourTempFile, sysTempFile, regularFile)); .thenReturn(Stream.of(ourTempFile, sysTempFile, regularFile));
// Configure Files.isDirectory // Configure Files.isDirectory
@ -262,28 +288,37 @@ public class TempFileCleanupServiceTest {
mockedFiles.when(() -> Files.exists(any(Path.class))).thenReturn(true); mockedFiles.when(() -> Files.exists(any(Path.class))).thenReturn(true);
// Configure Files.getLastModifiedTime to return recent timestamps // Configure Files.getLastModifiedTime to return recent timestamps
mockedFiles.when(() -> Files.getLastModifiedTime(any(Path.class))) mockedFiles
.thenReturn(FileTime.fromMillis(System.currentTimeMillis() - 60000)); // 1 minute ago .when(() -> Files.getLastModifiedTime(any(Path.class)))
.thenReturn(
FileTime.fromMillis(
System.currentTimeMillis() - 60000)); // 1 minute ago
// Configure Files.size to return normal size // Configure Files.size to return normal size
mockedFiles.when(() -> Files.size(any(Path.class))) mockedFiles.when(() -> Files.size(any(Path.class))).thenReturn(1024L); // 1 KB
.thenReturn(1024L); // 1 KB
// For deleteIfExists, track which files would be deleted // For deleteIfExists, track which files would be deleted
mockedFiles.when(() -> Files.deleteIfExists(any(Path.class))) mockedFiles
.thenAnswer(invocation -> { .when(() -> Files.deleteIfExists(any(Path.class)))
Path path = invocation.getArgument(0); .thenAnswer(
deletedFiles.add(path); invocation -> {
return true; Path path = invocation.getArgument(0);
}); deletedFiles.add(path);
return true;
});
// Act - set containerMode to true and maxAgeMillis to 0 for container startup cleanup // Act - set containerMode to true and maxAgeMillis to 0 for container startup cleanup
invokeCleanupDirectoryStreaming(systemTempDir, true, 0, 0); invokeCleanupDirectoryStreaming(systemTempDir, true, 0, 0);
// Assert - In container mode, both our temp files and system temp files should be deleted // Assert - In container mode, both our temp files and system temp files should be
// deleted
// regardless of age (when maxAgeMillis is 0) // regardless of age (when maxAgeMillis is 0)
assertTrue(deletedFiles.contains(ourTempFile), "Our temp file should be deleted in container mode"); assertTrue(
assertTrue(deletedFiles.contains(sysTempFile), "System temp file should be deleted in container mode"); deletedFiles.contains(ourTempFile),
"Our temp file should be deleted in container mode");
assertTrue(
deletedFiles.contains(sysTempFile),
"System temp file should be deleted in container mode");
assertFalse(deletedFiles.contains(regularFile), "Regular file should be preserved"); assertFalse(deletedFiles.contains(regularFile), "Regular file should be preserved");
} }
} }
@ -303,7 +338,8 @@ public class TempFileCleanupServiceTest {
// Use MockedStatic to mock Files operations // Use MockedStatic to mock Files operations
try (MockedStatic<Files> mockedFiles = mockStatic(Files.class)) { try (MockedStatic<Files> mockedFiles = mockStatic(Files.class)) {
// Mock Files.list for systemTempDir // Mock Files.list for systemTempDir
mockedFiles.when(() -> Files.list(eq(systemTempDir))) mockedFiles
.when(() -> Files.list(eq(systemTempDir)))
.thenReturn(Stream.of(emptyFile, recentEmptyFile)); .thenReturn(Stream.of(emptyFile, recentEmptyFile));
// Configure Files.isDirectory // Configure Files.isDirectory
@ -313,39 +349,46 @@ public class TempFileCleanupServiceTest {
mockedFiles.when(() -> Files.exists(any(Path.class))).thenReturn(true); mockedFiles.when(() -> Files.exists(any(Path.class))).thenReturn(true);
// Configure Files.getLastModifiedTime to return different times based on file names // Configure Files.getLastModifiedTime to return different times based on file names
mockedFiles.when(() -> Files.getLastModifiedTime(any(Path.class))) mockedFiles
.thenAnswer(invocation -> { .when(() -> Files.getLastModifiedTime(any(Path.class)))
Path path = invocation.getArgument(0); .thenAnswer(
String fileName = path.getFileName().toString(); invocation -> {
Path path = invocation.getArgument(0);
String fileName = path.getFileName().toString();
if (fileName.equals("empty.tmp")) { if (fileName.equals("empty.tmp")) {
// More than 5 minutes old // More than 5 minutes old
return FileTime.fromMillis(System.currentTimeMillis() - 6 * 60 * 1000); return FileTime.fromMillis(
} else { System.currentTimeMillis() - 6 * 60 * 1000);
// Less than 5 minutes old } else {
return FileTime.fromMillis(System.currentTimeMillis() - 2 * 60 * 1000); // Less than 5 minutes old
} return FileTime.fromMillis(
}); System.currentTimeMillis() - 2 * 60 * 1000);
}
});
// Configure Files.size to return 0 for empty files // Configure Files.size to return 0 for empty files
mockedFiles.when(() -> Files.size(any(Path.class))) mockedFiles.when(() -> Files.size(any(Path.class))).thenReturn(0L);
.thenReturn(0L);
// For deleteIfExists, track which files would be deleted // For deleteIfExists, track which files would be deleted
mockedFiles.when(() -> Files.deleteIfExists(any(Path.class))) mockedFiles
.thenAnswer(invocation -> { .when(() -> Files.deleteIfExists(any(Path.class)))
Path path = invocation.getArgument(0); .thenAnswer(
deletedFiles.add(path); invocation -> {
return true; Path path = invocation.getArgument(0);
}); deletedFiles.add(path);
return true;
});
// Act // Act
invokeCleanupDirectoryStreaming(systemTempDir, false, 0, 3600000); invokeCleanupDirectoryStreaming(systemTempDir, false, 0, 3600000);
// Assert // Assert
assertTrue(deletedFiles.contains(emptyFile), assertTrue(
deletedFiles.contains(emptyFile),
"Empty file older than 5 minutes should be deleted"); "Empty file older than 5 minutes should be deleted");
assertFalse(deletedFiles.contains(recentEmptyFile), assertFalse(
deletedFiles.contains(recentEmptyFile),
"Empty file newer than 5 minutes should not be deleted"); "Empty file newer than 5 minutes should not be deleted");
} }
} }
@ -370,17 +413,13 @@ public class TempFileCleanupServiceTest {
// Use MockedStatic to mock Files operations // Use MockedStatic to mock Files operations
try (MockedStatic<Files> mockedFiles = mockStatic(Files.class)) { try (MockedStatic<Files> mockedFiles = mockStatic(Files.class)) {
// Mock Files.list for each directory // Mock Files.list for each directory
mockedFiles.when(() -> Files.list(eq(systemTempDir))) mockedFiles.when(() -> Files.list(eq(systemTempDir))).thenReturn(Stream.of(dir1));
.thenReturn(Stream.of(dir1));
mockedFiles.when(() -> Files.list(eq(dir1))) mockedFiles.when(() -> Files.list(eq(dir1))).thenReturn(Stream.of(tempFile1, dir2));
.thenReturn(Stream.of(tempFile1, dir2));
mockedFiles.when(() -> Files.list(eq(dir2))) mockedFiles.when(() -> Files.list(eq(dir2))).thenReturn(Stream.of(tempFile2, dir3));
.thenReturn(Stream.of(tempFile2, dir3));
mockedFiles.when(() -> Files.list(eq(dir3))) mockedFiles.when(() -> Files.list(eq(dir3))).thenReturn(Stream.of(tempFile3));
.thenReturn(Stream.of(tempFile3));
// Configure Files.isDirectory for each path // Configure Files.isDirectory for each path
mockedFiles.when(() -> Files.isDirectory(eq(dir1))).thenReturn(true); mockedFiles.when(() -> Files.isDirectory(eq(dir1))).thenReturn(true);
@ -394,31 +433,35 @@ public class TempFileCleanupServiceTest {
mockedFiles.when(() -> Files.exists(any(Path.class))).thenReturn(true); mockedFiles.when(() -> Files.exists(any(Path.class))).thenReturn(true);
// Configure Files.getLastModifiedTime to return different times based on file names // Configure Files.getLastModifiedTime to return different times based on file names
mockedFiles.when(() -> Files.getLastModifiedTime(any(Path.class))) mockedFiles
.thenAnswer(invocation -> { .when(() -> Files.getLastModifiedTime(any(Path.class)))
Path path = invocation.getArgument(0); .thenAnswer(
String fileName = path.getFileName().toString(); invocation -> {
Path path = invocation.getArgument(0);
String fileName = path.getFileName().toString();
if (fileName.contains("old")) { if (fileName.contains("old")) {
// Old file // Old file
return FileTime.fromMillis(System.currentTimeMillis() - 5000000); return FileTime.fromMillis(
} else { System.currentTimeMillis() - 5000000);
// Recent file } else {
return FileTime.fromMillis(System.currentTimeMillis() - 60000); // Recent file
} return FileTime.fromMillis(System.currentTimeMillis() - 60000);
}); }
});
// Configure Files.size to return normal size // Configure Files.size to return normal size
mockedFiles.when(() -> Files.size(any(Path.class))) mockedFiles.when(() -> Files.size(any(Path.class))).thenReturn(1024L);
.thenReturn(1024L);
// For deleteIfExists, track which files would be deleted // For deleteIfExists, track which files would be deleted
mockedFiles.when(() -> Files.deleteIfExists(any(Path.class))) mockedFiles
.thenAnswer(invocation -> { .when(() -> Files.deleteIfExists(any(Path.class)))
Path path = invocation.getArgument(0); .thenAnswer(
deletedFiles.add(path); invocation -> {
return true; Path path = invocation.getArgument(0);
}); deletedFiles.add(path);
return true;
});
// Act // Act
invokeCleanupDirectoryStreaming(systemTempDir, false, 0, 3600000); invokeCleanupDirectoryStreaming(systemTempDir, false, 0, 3600000);
@ -430,14 +473,15 @@ public class TempFileCleanupServiceTest {
// Assert // Assert
assertFalse(deletedFiles.contains(tempFile1), "Recent temp file should be preserved"); assertFalse(deletedFiles.contains(tempFile1), "Recent temp file should be preserved");
assertFalse(deletedFiles.contains(tempFile2), "Recent temp file should be preserved"); assertFalse(deletedFiles.contains(tempFile2), "Recent temp file should be preserved");
assertTrue(deletedFiles.contains(tempFile3), "Old temp file in nested directory should be deleted"); assertTrue(
deletedFiles.contains(tempFile3),
"Old temp file in nested directory should be deleted");
} }
} }
/** /** Helper method to invoke the private cleanupDirectoryStreaming method using reflection */
* Helper method to invoke the private cleanupDirectoryStreaming method using reflection private void invokeCleanupDirectoryStreaming(
*/ Path directory, boolean containerMode, int depth, long maxAgeMillis)
private void invokeCleanupDirectoryStreaming(Path directory, boolean containerMode, int depth, long maxAgeMillis)
throws IOException { throws IOException {
try { try {
// Create a consumer that tracks deleted files // Create a consumer that tracks deleted files
@ -445,13 +489,26 @@ public class TempFileCleanupServiceTest {
Consumer<Path> deleteCallback = path -> deleteCount.incrementAndGet(); Consumer<Path> deleteCallback = path -> deleteCount.incrementAndGet();
// Get the method with updated signature // Get the method with updated signature
var method = TempFileCleanupService.class.getDeclaredMethod( var method =
"cleanupDirectoryStreaming", TempFileCleanupService.class.getDeclaredMethod(
Path.class, boolean.class, int.class, long.class, boolean.class, Consumer.class); "cleanupDirectoryStreaming",
Path.class,
boolean.class,
int.class,
long.class,
boolean.class,
Consumer.class);
method.setAccessible(true); method.setAccessible(true);
// Invoke the method with appropriate parameters // Invoke the method with appropriate parameters
method.invoke(cleanupService, directory, containerMode, depth, maxAgeMillis, false, deleteCallback); method.invoke(
cleanupService,
directory,
containerMode,
depth,
maxAgeMillis,
false,
deleteCallback);
} catch (Exception e) { } catch (Exception e) {
throw new RuntimeException("Error invoking cleanupDirectoryStreaming", e); throw new RuntimeException("Error invoking cleanupDirectoryStreaming", e);
} }

21
app/common/src/test/java/stirling/software/common/util/CheckProgramInstallTest.java
View File

@ -1,14 +1,5 @@
package stirling.software.common.util; package stirling.software.common.util;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.Arrays;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import stirling.software.common.util.ProcessExecutor.ProcessExecutorResult;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
@ -19,6 +10,18 @@ import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.Arrays;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import stirling.software.common.util.ProcessExecutor.ProcessExecutorResult;
class CheckProgramInstallTest { class CheckProgramInstallTest {
private MockedStatic<ProcessExecutor> mockProcessExecutor; private MockedStatic<ProcessExecutor> mockProcessExecutor;

12
app/common/src/test/java/stirling/software/common/util/CustomHtmlSanitizerTest.java
View File

@ -23,15 +23,19 @@ class CustomHtmlSanitizerTest {
@BeforeEach @BeforeEach
void setUp() { void setUp() {
SsrfProtectionService mockSsrfProtectionService = mock(SsrfProtectionService.class); SsrfProtectionService mockSsrfProtectionService = mock(SsrfProtectionService.class);
stirling.software.common.model.ApplicationProperties mockApplicationProperties = mock(stirling.software.common.model.ApplicationProperties.class); stirling.software.common.model.ApplicationProperties mockApplicationProperties =
stirling.software.common.model.ApplicationProperties.System mockSystem = mock(stirling.software.common.model.ApplicationProperties.System.class); mock(stirling.software.common.model.ApplicationProperties.class);
stirling.software.common.model.ApplicationProperties.System mockSystem =
mock(stirling.software.common.model.ApplicationProperties.System.class);
// Allow all URLs by default for basic tests // Allow all URLs by default for basic tests
when(mockSsrfProtectionService.isUrlAllowed(org.mockito.ArgumentMatchers.anyString())).thenReturn(true); when(mockSsrfProtectionService.isUrlAllowed(org.mockito.ArgumentMatchers.anyString()))
.thenReturn(true);
when(mockApplicationProperties.getSystem()).thenReturn(mockSystem); when(mockApplicationProperties.getSystem()).thenReturn(mockSystem);
when(mockSystem.getDisableSanitize()).thenReturn(false); // Enable sanitization for tests when(mockSystem.getDisableSanitize()).thenReturn(false); // Enable sanitization for tests
customHtmlSanitizer = new CustomHtmlSanitizer(mockSsrfProtectionService, mockApplicationProperties); customHtmlSanitizer =
new CustomHtmlSanitizer(mockSsrfProtectionService, mockApplicationProperties);
} }
@ParameterizedTest @ParameterizedTest

753
app/common/src/test/java/stirling/software/common/util/EmlToPdfTest.java
View File

File diff suppressed because it is too large Load Diff

1
app/common/src/test/java/stirling/software/common/util/FileMonitorTest.java
View File

@ -19,6 +19,7 @@ import org.junit.jupiter.api.io.TempDir;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoExtension;
import stirling.software.common.configuration.RuntimePathConfig; import stirling.software.common.configuration.RuntimePathConfig;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)

28
app/common/src/test/java/stirling/software/common/util/FileToPdfTest.java
View File

@ -1,15 +1,14 @@
package stirling.software.common.util; package stirling.software.common.util;
import java.nio.file.Files;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
import static org.mockito.ArgumentMatchers.anyString;
import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.nio.file.Files;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
@ -24,14 +23,18 @@ public class FileToPdfTest {
@BeforeEach @BeforeEach
void setUp() { void setUp() {
SsrfProtectionService mockSsrfProtectionService = mock(SsrfProtectionService.class); SsrfProtectionService mockSsrfProtectionService = mock(SsrfProtectionService.class);
stirling.software.common.model.ApplicationProperties mockApplicationProperties = mock(stirling.software.common.model.ApplicationProperties.class); stirling.software.common.model.ApplicationProperties mockApplicationProperties =
stirling.software.common.model.ApplicationProperties.System mockSystem = mock(stirling.software.common.model.ApplicationProperties.System.class); mock(stirling.software.common.model.ApplicationProperties.class);
stirling.software.common.model.ApplicationProperties.System mockSystem =
mock(stirling.software.common.model.ApplicationProperties.System.class);
when(mockSsrfProtectionService.isUrlAllowed(org.mockito.ArgumentMatchers.anyString())).thenReturn(true); when(mockSsrfProtectionService.isUrlAllowed(org.mockito.ArgumentMatchers.anyString()))
.thenReturn(true);
when(mockApplicationProperties.getSystem()).thenReturn(mockSystem); when(mockApplicationProperties.getSystem()).thenReturn(mockSystem);
when(mockSystem.getDisableSanitize()).thenReturn(false); when(mockSystem.getDisableSanitize()).thenReturn(false);
customHtmlSanitizer = new CustomHtmlSanitizer(mockSsrfProtectionService, mockApplicationProperties); customHtmlSanitizer =
new CustomHtmlSanitizer(mockSsrfProtectionService, mockApplicationProperties);
} }
/** /**
@ -48,8 +51,8 @@ public class FileToPdfTest {
// Mock the temp file creation to return real temp files // Mock the temp file creation to return real temp files
try { try {
when(tempFileManager.createTempFile(anyString())) when(tempFileManager.createTempFile(anyString()))
.thenReturn(Files.createTempFile("test", ".pdf").toFile()) .thenReturn(Files.createTempFile("test", ".pdf").toFile())
.thenReturn(Files.createTempFile("test", ".html").toFile()); .thenReturn(Files.createTempFile("test", ".html").toFile());
} catch (IOException e) { } catch (IOException e) {
throw new RuntimeException(e); throw new RuntimeException(e);
} }
@ -60,7 +63,12 @@ public class FileToPdfTest {
Exception.class, Exception.class,
() -> () ->
FileToPdf.convertHtmlToPdf( FileToPdf.convertHtmlToPdf(
"/path/", request, fileBytes, fileName, tempFileManager, customHtmlSanitizer)); "/path/",
request,
fileBytes,
fileName,
tempFileManager,
customHtmlSanitizer));
assertNotNull(thrown); assertNotNull(thrown);
} }

12
app/common/src/test/java/stirling/software/common/util/ProviderUtilsTest.java
View File

@ -1,21 +1,23 @@
package stirling.software.common.util; package stirling.software.common.util;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.List; import java.util.List;
import java.util.stream.Stream; import java.util.stream.Stream;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoExtension;
import stirling.software.common.model.enumeration.UsernameAttribute; import stirling.software.common.model.enumeration.UsernameAttribute;
import stirling.software.common.model.oauth2.GitHubProvider; import stirling.software.common.model.oauth2.GitHubProvider;
import stirling.software.common.model.oauth2.GoogleProvider; import stirling.software.common.model.oauth2.GoogleProvider;
import stirling.software.common.model.oauth2.Provider; import stirling.software.common.model.oauth2.Provider;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
class ProviderUtilsTest { class ProviderUtilsTest {
@ -40,7 +42,7 @@ class ProviderUtilsTest {
public static Stream<Arguments> providerParams() { public static Stream<Arguments> providerParams() {
Provider generic = null; Provider generic = null;
var google = var google =
new GoogleProvider(null, "clientSecret", List.of("scope"), UsernameAttribute.EMAIL); new GoogleProvider(null, "clientSecret", List.of("scope"), UsernameAttribute.EMAIL);
var github = new GitHubProvider("clientId", "", List.of("scope"), UsernameAttribute.LOGIN); var github = new GitHubProvider("clientId", "", List.of("scope"), UsernameAttribute.LOGIN);
return Stream.of(Arguments.of(generic), Arguments.of(google), Arguments.of(github)); return Stream.of(Arguments.of(generic), Arguments.of(google), Arguments.of(github));

7
app/common/src/test/java/stirling/software/common/util/SpringContextHolderTest.java
View File

@ -42,7 +42,6 @@ class SpringContextHolderTest {
verify(mockApplicationContext).getBean(TestBean.class); verify(mockApplicationContext).getBean(TestBean.class);
} }
@Test @Test
void testGetBean_ApplicationContextNotSet() { void testGetBean_ApplicationContextNotSet() {
// Don't set application context // Don't set application context
@ -58,7 +57,8 @@ class SpringContextHolderTest {
void testGetBean_BeanNotFound() { void testGetBean_BeanNotFound() {
// Arrange // Arrange
contextHolder.setApplicationContext(mockApplicationContext); contextHolder.setApplicationContext(mockApplicationContext);
when(mockApplicationContext.getBean(TestBean.class)).thenThrow(new org.springframework.beans.BeansException("Bean not found") {}); when(mockApplicationContext.getBean(TestBean.class))
.thenThrow(new org.springframework.beans.BeansException("Bean not found") {});
// Act // Act
TestBean result = SpringContextHolder.getBean(TestBean.class); TestBean result = SpringContextHolder.getBean(TestBean.class);
@ -68,6 +68,5 @@ class SpringContextHolderTest {
} }
// Simple test class // Simple test class
private static class TestBean { private static class TestBean {}
}
} }

8
app/common/src/test/java/stirling/software/common/util/misc/HighContrastColorReplaceDeciderTest.java
View File

@ -1,11 +1,13 @@
package stirling.software.common.util.misc; package stirling.software.common.util.misc;
import org.junit.jupiter.api.Test;
import stirling.software.common.model.api.misc.HighContrastColorCombination;
import stirling.software.common.model.api.misc.ReplaceAndInvert;
import static org.junit.jupiter.api.Assertions.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import org.junit.jupiter.api.Test;
import stirling.software.common.model.api.misc.HighContrastColorCombination;
import stirling.software.common.model.api.misc.ReplaceAndInvert;
class HighContrastColorReplaceDeciderTest { class HighContrastColorReplaceDeciderTest {
@Test @Test

1
app/common/src/test/java/stirling/software/common/util/misc/InvertFullColorStrategyTest.java
View File

@ -26,6 +26,7 @@ import org.junit.jupiter.api.Test;
import org.springframework.core.io.InputStreamResource; import org.springframework.core.io.InputStreamResource;
import org.springframework.mock.web.MockMultipartFile; import org.springframework.mock.web.MockMultipartFile;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
import stirling.software.common.model.api.misc.ReplaceAndInvert; import stirling.software.common.model.api.misc.ReplaceAndInvert;
class InvertFullColorStrategyTest { class InvertFullColorStrategyTest {

1
app/common/src/test/java/stirling/software/common/util/misc/ReplaceAndInvertColorStrategyTest.java
View File

@ -9,6 +9,7 @@ import org.junit.jupiter.api.Test;
import org.springframework.core.io.InputStreamResource; import org.springframework.core.io.InputStreamResource;
import org.springframework.mock.web.MockMultipartFile; import org.springframework.mock.web.MockMultipartFile;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
import stirling.software.common.model.api.misc.ReplaceAndInvert; import stirling.software.common.model.api.misc.ReplaceAndInvert;
class ReplaceAndInvertColorStrategyTest { class ReplaceAndInvertColorStrategyTest {

11
app/common/src/test/java/stirling/software/common/util/propertyeditor/StringToArrayListPropertyEditorTest.java
View File

@ -1,14 +1,17 @@
package stirling.software.common.util.propertyeditor; package stirling.software.common.util.propertyeditor;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import stirling.software.common.model.api.security.RedactionArea;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import stirling.software.common.model.api.security.RedactionArea;
class StringToArrayListPropertyEditorTest { class StringToArrayListPropertyEditorTest {
private StringToArrayListPropertyEditor editor; private StringToArrayListPropertyEditor editor;

97
app/core/src/test/java/stirling/software/SPDF/controller/api/EditTableOfContentsControllerTest.java
View File

@ -36,14 +36,11 @@ import stirling.software.common.service.CustomPDFDocumentFactory;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
class EditTableOfContentsControllerTest { class EditTableOfContentsControllerTest {
@Mock @Mock private CustomPDFDocumentFactory pdfDocumentFactory;
private CustomPDFDocumentFactory pdfDocumentFactory;
@Mock @Mock private ObjectMapper objectMapper;
private ObjectMapper objectMapper;
@InjectMocks @InjectMocks private EditTableOfContentsController editTableOfContentsController;
private EditTableOfContentsController editTableOfContentsController;
private MockMultipartFile mockFile; private MockMultipartFile mockFile;
private PDDocument mockDocument; private PDDocument mockDocument;
@ -56,7 +53,9 @@ class EditTableOfContentsControllerTest {
@BeforeEach @BeforeEach
void setUp() { void setUp() {
mockFile = new MockMultipartFile("file", "test.pdf", "application/pdf", "PDF content".getBytes()); mockFile =
new MockMultipartFile(
"file", "test.pdf", "application/pdf", "PDF content".getBytes());
mockDocument = mock(PDDocument.class); mockDocument = mock(PDDocument.class);
mockCatalog = mock(PDDocumentCatalog.class); mockCatalog = mock(PDDocumentCatalog.class);
mockPages = mock(PDPageTree.class); mockPages = mock(PDPageTree.class);
@ -149,7 +148,8 @@ class EditTableOfContentsControllerTest {
assertEquals(1, parentBookmark.get("pageNumber")); assertEquals(1, parentBookmark.get("pageNumber"));
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
List<Map<String, Object>> children = (List<Map<String, Object>>) parentBookmark.get("children"); List<Map<String, Object>> children =
(List<Map<String, Object>>) parentBookmark.get("children");
assertEquals(1, children.size()); assertEquals(1, children.size());
Map<String, Object> childBookmark = children.get(0); Map<String, Object> childBookmark = children.get(0);
@ -202,17 +202,21 @@ class EditTableOfContentsControllerTest {
bookmarks.add(bookmark); bookmarks.add(bookmark);
when(pdfDocumentFactory.load(mockFile)).thenReturn(mockDocument); when(pdfDocumentFactory.load(mockFile)).thenReturn(mockDocument);
when(objectMapper.readValue(eq(request.getBookmarkData()), any(TypeReference.class))).thenReturn(bookmarks); when(objectMapper.readValue(eq(request.getBookmarkData()), any(TypeReference.class)))
.thenReturn(bookmarks);
when(mockDocument.getDocumentCatalog()).thenReturn(mockCatalog); when(mockDocument.getDocumentCatalog()).thenReturn(mockCatalog);
when(mockDocument.getNumberOfPages()).thenReturn(5); when(mockDocument.getNumberOfPages()).thenReturn(5);
when(mockDocument.getPage(0)).thenReturn(mockPage1); when(mockDocument.getPage(0)).thenReturn(mockPage1);
// Mock saving behavior // Mock saving behavior
doAnswer(invocation -> { doAnswer(
ByteArrayOutputStream baos = invocation.getArgument(0); invocation -> {
baos.write("mocked pdf content".getBytes()); ByteArrayOutputStream baos = invocation.getArgument(0);
return null; baos.write("mocked pdf content".getBytes());
}).when(mockDocument).save(any(ByteArrayOutputStream.class)); return null;
})
.when(mockDocument)
.save(any(ByteArrayOutputStream.class));
// When // When
ResponseEntity<byte[]> result = editTableOfContentsController.editTableOfContents(request); ResponseEntity<byte[]> result = editTableOfContentsController.editTableOfContents(request);
@ -221,7 +225,8 @@ class EditTableOfContentsControllerTest {
assertNotNull(result); assertNotNull(result);
assertNotNull(result.getBody()); assertNotNull(result.getBody());
ArgumentCaptor<PDDocumentOutline> outlineCaptor = ArgumentCaptor.forClass(PDDocumentOutline.class); ArgumentCaptor<PDDocumentOutline> outlineCaptor =
ArgumentCaptor.forClass(PDDocumentOutline.class);
verify(mockCatalog).setDocumentOutline(outlineCaptor.capture()); verify(mockCatalog).setDocumentOutline(outlineCaptor.capture());
PDDocumentOutline capturedOutline = outlineCaptor.getValue(); PDDocumentOutline capturedOutline = outlineCaptor.getValue();
@ -236,7 +241,8 @@ class EditTableOfContentsControllerTest {
EditTableOfContentsRequest request = new EditTableOfContentsRequest(); EditTableOfContentsRequest request = new EditTableOfContentsRequest();
request.setFileInput(mockFile); request.setFileInput(mockFile);
String bookmarkJson = "[{\"title\":\"Chapter 1\",\"pageNumber\":1,\"children\":[{\"title\":\"Section 1.1\",\"pageNumber\":2,\"children\":[]}]}]"; String bookmarkJson =
"[{\"title\":\"Chapter 1\",\"pageNumber\":1,\"children\":[{\"title\":\"Section 1.1\",\"pageNumber\":2,\"children\":[]}]}]";
request.setBookmarkData(bookmarkJson); request.setBookmarkData(bookmarkJson);
List<BookmarkItem> bookmarks = new ArrayList<>(); List<BookmarkItem> bookmarks = new ArrayList<>();
@ -255,17 +261,21 @@ class EditTableOfContentsControllerTest {
bookmarks.add(parentBookmark); bookmarks.add(parentBookmark);
when(pdfDocumentFactory.load(mockFile)).thenReturn(mockDocument); when(pdfDocumentFactory.load(mockFile)).thenReturn(mockDocument);
when(objectMapper.readValue(eq(bookmarkJson), any(TypeReference.class))).thenReturn(bookmarks); when(objectMapper.readValue(eq(bookmarkJson), any(TypeReference.class)))
.thenReturn(bookmarks);
when(mockDocument.getDocumentCatalog()).thenReturn(mockCatalog); when(mockDocument.getDocumentCatalog()).thenReturn(mockCatalog);
when(mockDocument.getNumberOfPages()).thenReturn(5); when(mockDocument.getNumberOfPages()).thenReturn(5);
when(mockDocument.getPage(0)).thenReturn(mockPage1); when(mockDocument.getPage(0)).thenReturn(mockPage1);
when(mockDocument.getPage(1)).thenReturn(mockPage2); when(mockDocument.getPage(1)).thenReturn(mockPage2);
doAnswer(invocation -> { doAnswer(
ByteArrayOutputStream baos = invocation.getArgument(0); invocation -> {
baos.write("mocked pdf content".getBytes()); ByteArrayOutputStream baos = invocation.getArgument(0);
return null; baos.write("mocked pdf content".getBytes());
}).when(mockDocument).save(any(ByteArrayOutputStream.class)); return null;
})
.when(mockDocument)
.save(any(ByteArrayOutputStream.class));
// When // When
ResponseEntity<byte[]> result = editTableOfContentsController.editTableOfContents(request); ResponseEntity<byte[]> result = editTableOfContentsController.editTableOfContents(request);
@ -281,7 +291,8 @@ class EditTableOfContentsControllerTest {
// Given // Given
EditTableOfContentsRequest request = new EditTableOfContentsRequest(); EditTableOfContentsRequest request = new EditTableOfContentsRequest();
request.setFileInput(mockFile); request.setFileInput(mockFile);
request.setBookmarkData("[{\"title\":\"Chapter 1\",\"pageNumber\":-5,\"children\":[]},{\"title\":\"Chapter 2\",\"pageNumber\":100,\"children\":[]}]"); request.setBookmarkData(
"[{\"title\":\"Chapter 1\",\"pageNumber\":-5,\"children\":[]},{\"title\":\"Chapter 2\",\"pageNumber\":100,\"children\":[]}]");
List<BookmarkItem> bookmarks = new ArrayList<>(); List<BookmarkItem> bookmarks = new ArrayList<>();
@ -299,17 +310,21 @@ class EditTableOfContentsControllerTest {
bookmarks.add(bookmark2); bookmarks.add(bookmark2);
when(pdfDocumentFactory.load(mockFile)).thenReturn(mockDocument); when(pdfDocumentFactory.load(mockFile)).thenReturn(mockDocument);
when(objectMapper.readValue(eq(request.getBookmarkData()), any(TypeReference.class))).thenReturn(bookmarks); when(objectMapper.readValue(eq(request.getBookmarkData()), any(TypeReference.class)))
.thenReturn(bookmarks);
when(mockDocument.getDocumentCatalog()).thenReturn(mockCatalog); when(mockDocument.getDocumentCatalog()).thenReturn(mockCatalog);
when(mockDocument.getNumberOfPages()).thenReturn(5); when(mockDocument.getNumberOfPages()).thenReturn(5);
when(mockDocument.getPage(0)).thenReturn(mockPage1); // For negative page number when(mockDocument.getPage(0)).thenReturn(mockPage1); // For negative page number
when(mockDocument.getPage(4)).thenReturn(mockPage2); // For page number exceeding bounds when(mockDocument.getPage(4)).thenReturn(mockPage2); // For page number exceeding bounds
doAnswer(invocation -> { doAnswer(
ByteArrayOutputStream baos = invocation.getArgument(0); invocation -> {
baos.write("mocked pdf content".getBytes()); ByteArrayOutputStream baos = invocation.getArgument(0);
return null; baos.write("mocked pdf content".getBytes());
}).when(mockDocument).save(any(ByteArrayOutputStream.class)); return null;
})
.when(mockDocument)
.save(any(ByteArrayOutputStream.class));
// When // When
ResponseEntity<byte[]> result = editTableOfContentsController.editTableOfContents(request); ResponseEntity<byte[]> result = editTableOfContentsController.editTableOfContents(request);
@ -332,16 +347,20 @@ class EditTableOfContentsControllerTest {
when(mockDocument.getPage(2)).thenReturn(mockPage1); // 0-indexed when(mockDocument.getPage(2)).thenReturn(mockPage1); // 0-indexed
// When // When
Method createOutlineItemMethod = EditTableOfContentsController.class.getDeclaredMethod("createOutlineItem", PDDocument.class, BookmarkItem.class); Method createOutlineItemMethod =
EditTableOfContentsController.class.getDeclaredMethod(
"createOutlineItem", PDDocument.class, BookmarkItem.class);
createOutlineItemMethod.setAccessible(true); createOutlineItemMethod.setAccessible(true);
PDOutlineItem result = (PDOutlineItem) createOutlineItemMethod.invoke(editTableOfContentsController, mockDocument, bookmark); PDOutlineItem result =
(PDOutlineItem)
createOutlineItemMethod.invoke(
editTableOfContentsController, mockDocument, bookmark);
// Then // Then
assertNotNull(result); assertNotNull(result);
verify(mockDocument).getPage(2); verify(mockDocument).getPage(2);
} }
@Test @Test
void testBookmarkItem_GettersAndSetters() { void testBookmarkItem_GettersAndSetters() {
// Given // Given
@ -365,18 +384,24 @@ class EditTableOfContentsControllerTest {
EditTableOfContentsRequest request = new EditTableOfContentsRequest(); EditTableOfContentsRequest request = new EditTableOfContentsRequest();
request.setFileInput(mockFile); request.setFileInput(mockFile);
when(pdfDocumentFactory.load(mockFile)).thenThrow(new RuntimeException("Failed to load PDF")); when(pdfDocumentFactory.load(mockFile))
.thenThrow(new RuntimeException("Failed to load PDF"));
// When & Then // When & Then
assertThrows(RuntimeException.class, () -> editTableOfContentsController.editTableOfContents(request)); assertThrows(
RuntimeException.class,
() -> editTableOfContentsController.editTableOfContents(request));
} }
@Test @Test
void testExtractBookmarks_IOExceptionDuringLoad_ThrowsException() throws Exception { void testExtractBookmarks_IOExceptionDuringLoad_ThrowsException() throws Exception {
// Given // Given
when(pdfDocumentFactory.load(mockFile)).thenThrow(new RuntimeException("Failed to load PDF")); when(pdfDocumentFactory.load(mockFile))
.thenThrow(new RuntimeException("Failed to load PDF"));
// When & Then // When & Then
assertThrows(RuntimeException.class, () -> editTableOfContentsController.extractBookmarks(mockFile)); assertThrows(
RuntimeException.class,
() -> editTableOfContentsController.extractBookmarks(mockFile));
} }
} }

66
app/core/src/test/java/stirling/software/SPDF/controller/api/MergeControllerTest.java
View File

@ -29,11 +29,9 @@ import stirling.software.common.service.CustomPDFDocumentFactory;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
class MergeControllerTest { class MergeControllerTest {
@Mock @Mock private CustomPDFDocumentFactory pdfDocumentFactory;
private CustomPDFDocumentFactory pdfDocumentFactory;
@InjectMocks @InjectMocks private MergeController mergeController;
private MergeController mergeController;
private MockMultipartFile mockFile1; private MockMultipartFile mockFile1;
private MockMultipartFile mockFile2; private MockMultipartFile mockFile2;
@ -47,9 +45,15 @@ class MergeControllerTest {
@BeforeEach @BeforeEach
void setUp() { void setUp() {
mockFile1 = new MockMultipartFile("file1", "document1.pdf", "application/pdf", "PDF content 1".getBytes()); mockFile1 =
mockFile2 = new MockMultipartFile("file2", "document2.pdf", "application/pdf", "PDF content 2".getBytes()); new MockMultipartFile(
mockFile3 = new MockMultipartFile("file3", "chapter3.pdf", "application/pdf", "PDF content 3".getBytes()); "file1", "document1.pdf", "application/pdf", "PDF content 1".getBytes());
mockFile2 =
new MockMultipartFile(
"file2", "document2.pdf", "application/pdf", "PDF content 2".getBytes());
mockFile3 =
new MockMultipartFile(
"file3", "chapter3.pdf", "application/pdf", "PDF content 3".getBytes());
mockDocument = mock(PDDocument.class); mockDocument = mock(PDDocument.class);
mockMergedDocument = mock(PDDocument.class); mockMergedDocument = mock(PDDocument.class);
@ -85,12 +89,15 @@ class MergeControllerTest {
when(doc3.getNumberOfPages()).thenReturn(2); when(doc3.getNumberOfPages()).thenReturn(2);
// When // When
Method addTableOfContentsMethod = MergeController.class.getDeclaredMethod("addTableOfContents", PDDocument.class, MultipartFile[].class); Method addTableOfContentsMethod =
MergeController.class.getDeclaredMethod(
"addTableOfContents", PDDocument.class, MultipartFile[].class);
addTableOfContentsMethod.setAccessible(true); addTableOfContentsMethod.setAccessible(true);
addTableOfContentsMethod.invoke(mergeController, mockMergedDocument, files); addTableOfContentsMethod.invoke(mergeController, mockMergedDocument, files);
// Then // Then
ArgumentCaptor<PDDocumentOutline> outlineCaptor = ArgumentCaptor.forClass(PDDocumentOutline.class); ArgumentCaptor<PDDocumentOutline> outlineCaptor =
ArgumentCaptor.forClass(PDDocumentOutline.class);
verify(mockCatalog).setDocumentOutline(outlineCaptor.capture()); verify(mockCatalog).setDocumentOutline(outlineCaptor.capture());
PDDocumentOutline capturedOutline = outlineCaptor.getValue(); PDDocumentOutline capturedOutline = outlineCaptor.getValue();
@ -121,7 +128,9 @@ class MergeControllerTest {
when(doc1.getNumberOfPages()).thenReturn(3); when(doc1.getNumberOfPages()).thenReturn(3);
// When // When
Method addTableOfContentsMethod = MergeController.class.getDeclaredMethod("addTableOfContents", PDDocument.class, MultipartFile[].class); Method addTableOfContentsMethod =
MergeController.class.getDeclaredMethod(
"addTableOfContents", PDDocument.class, MultipartFile[].class);
addTableOfContentsMethod.setAccessible(true); addTableOfContentsMethod.setAccessible(true);
addTableOfContentsMethod.invoke(mergeController, mockMergedDocument, files); addTableOfContentsMethod.invoke(mergeController, mockMergedDocument, files);
@ -138,7 +147,9 @@ class MergeControllerTest {
when(mockMergedDocument.getDocumentCatalog()).thenReturn(mockCatalog); when(mockMergedDocument.getDocumentCatalog()).thenReturn(mockCatalog);
// When // When
Method addTableOfContentsMethod = MergeController.class.getDeclaredMethod("addTableOfContents", PDDocument.class, MultipartFile[].class); Method addTableOfContentsMethod =
MergeController.class.getDeclaredMethod(
"addTableOfContents", PDDocument.class, MultipartFile[].class);
addTableOfContentsMethod.setAccessible(true); addTableOfContentsMethod.setAccessible(true);
addTableOfContentsMethod.invoke(mergeController, mockMergedDocument, files); addTableOfContentsMethod.invoke(mergeController, mockMergedDocument, files);
@ -155,7 +166,8 @@ class MergeControllerTest {
when(mockMergedDocument.getDocumentCatalog()).thenReturn(mockCatalog); when(mockMergedDocument.getDocumentCatalog()).thenReturn(mockCatalog);
when(mockMergedDocument.getNumberOfPages()).thenReturn(4); when(mockMergedDocument.getNumberOfPages()).thenReturn(4);
when(mockMergedDocument.getPage(anyInt())).thenReturn(mockPage1); // Use anyInt() to avoid stubbing conflicts when(mockMergedDocument.getPage(anyInt()))
.thenReturn(mockPage1); // Use anyInt() to avoid stubbing conflicts
// First document loads successfully // First document loads successfully
PDDocument doc1 = mock(PDDocument.class); PDDocument doc1 = mock(PDDocument.class);
@ -163,16 +175,18 @@ class MergeControllerTest {
when(doc1.getNumberOfPages()).thenReturn(2); when(doc1.getNumberOfPages()).thenReturn(2);
// Second document throws IOException // Second document throws IOException
when(pdfDocumentFactory.load(mockFile2)).thenThrow(new IOException("Failed to load document")); when(pdfDocumentFactory.load(mockFile2))
.thenThrow(new IOException("Failed to load document"));
// When // When
Method addTableOfContentsMethod = MergeController.class.getDeclaredMethod("addTableOfContents", PDDocument.class, MultipartFile[].class); Method addTableOfContentsMethod =
MergeController.class.getDeclaredMethod(
"addTableOfContents", PDDocument.class, MultipartFile[].class);
addTableOfContentsMethod.setAccessible(true); addTableOfContentsMethod.setAccessible(true);
// Should not throw exception // Should not throw exception
assertDoesNotThrow(() -> assertDoesNotThrow(
addTableOfContentsMethod.invoke(mergeController, mockMergedDocument, files) () -> addTableOfContentsMethod.invoke(mergeController, mockMergedDocument, files));
);
// Then // Then
verify(mockCatalog).setDocumentOutline(any(PDDocumentOutline.class)); verify(mockCatalog).setDocumentOutline(any(PDDocumentOutline.class));
@ -184,7 +198,9 @@ class MergeControllerTest {
@Test @Test
void testAddTableOfContents_FilenameWithoutExtension_UsesFullName() throws Exception { void testAddTableOfContents_FilenameWithoutExtension_UsesFullName() throws Exception {
// Given // Given
MockMultipartFile fileWithoutExtension = new MockMultipartFile("file", "document_no_ext", "application/pdf", "PDF content".getBytes()); MockMultipartFile fileWithoutExtension =
new MockMultipartFile(
"file", "document_no_ext", "application/pdf", "PDF content".getBytes());
MultipartFile[] files = {fileWithoutExtension}; MultipartFile[] files = {fileWithoutExtension};
when(mockMergedDocument.getDocumentCatalog()).thenReturn(mockCatalog); when(mockMergedDocument.getDocumentCatalog()).thenReturn(mockCatalog);
@ -196,7 +212,9 @@ class MergeControllerTest {
when(doc.getNumberOfPages()).thenReturn(1); when(doc.getNumberOfPages()).thenReturn(1);
// When // When
Method addTableOfContentsMethod = MergeController.class.getDeclaredMethod("addTableOfContents", PDDocument.class, MultipartFile[].class); Method addTableOfContentsMethod =
MergeController.class.getDeclaredMethod(
"addTableOfContents", PDDocument.class, MultipartFile[].class);
addTableOfContentsMethod.setAccessible(true); addTableOfContentsMethod.setAccessible(true);
addTableOfContentsMethod.invoke(mergeController, mockMergedDocument, files); addTableOfContentsMethod.invoke(mergeController, mockMergedDocument, files);
@ -218,13 +236,14 @@ class MergeControllerTest {
when(doc1.getNumberOfPages()).thenReturn(3); when(doc1.getNumberOfPages()).thenReturn(3);
// When // When
Method addTableOfContentsMethod = MergeController.class.getDeclaredMethod("addTableOfContents", PDDocument.class, MultipartFile[].class); Method addTableOfContentsMethod =
MergeController.class.getDeclaredMethod(
"addTableOfContents", PDDocument.class, MultipartFile[].class);
addTableOfContentsMethod.setAccessible(true); addTableOfContentsMethod.setAccessible(true);
// Should not throw exception // Should not throw exception
assertDoesNotThrow(() -> assertDoesNotThrow(
addTableOfContentsMethod.invoke(mergeController, mockMergedDocument, files) () -> addTableOfContentsMethod.invoke(mergeController, mockMergedDocument, files));
);
// Then // Then
verify(mockCatalog).setDocumentOutline(any(PDDocumentOutline.class)); verify(mockCatalog).setDocumentOutline(any(PDDocumentOutline.class));
@ -275,5 +294,4 @@ class MergeControllerTest {
assertEquals(mockMergedDocument, result); assertEquals(mockMergedDocument, result);
verify(mockMergedDocument, never()).addPage(any(PDPage.class)); verify(mockMergedDocument, never()).addPage(any(PDPage.class));
} }
} }

56
app/core/src/test/java/stirling/software/SPDF/controller/api/misc/AttachmentControllerTest.java
View File

@ -4,8 +4,6 @@ import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*; import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*; import static org.mockito.Mockito.*;
import org.mockito.MockedStatic;
import java.io.IOException; import java.io.IOException;
import java.util.List; import java.util.List;
@ -15,6 +13,7 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
@ -29,14 +28,11 @@ import stirling.software.common.util.WebResponseUtils;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
class AttachmentControllerTest { class AttachmentControllerTest {
@Mock @Mock private CustomPDFDocumentFactory pdfDocumentFactory;
private CustomPDFDocumentFactory pdfDocumentFactory;
@Mock @Mock private AttachmentServiceInterface pdfAttachmentService;
private AttachmentServiceInterface pdfAttachmentService;
@InjectMocks @InjectMocks private AttachmentController attachmentController;
private AttachmentController attachmentController;
private MockMultipartFile pdfFile; private MockMultipartFile pdfFile;
private MockMultipartFile attachment1; private MockMultipartFile attachment1;
@ -47,9 +43,15 @@ class AttachmentControllerTest {
@BeforeEach @BeforeEach
void setUp() { void setUp() {
pdfFile = new MockMultipartFile("fileInput", "test.pdf", "application/pdf", "PDF content".getBytes()); pdfFile =
attachment1 = new MockMultipartFile("attachment1", "file1.txt", "text/plain", "File 1 content".getBytes()); new MockMultipartFile(
attachment2 = new MockMultipartFile("attachment2", "file2.jpg", "image/jpeg", "Image content".getBytes()); "fileInput", "test.pdf", "application/pdf", "PDF content".getBytes());
attachment1 =
new MockMultipartFile(
"attachment1", "file1.txt", "text/plain", "File 1 content".getBytes());
attachment2 =
new MockMultipartFile(
"attachment2", "file2.jpg", "image/jpeg", "Image content".getBytes());
request = new AddAttachmentRequest(); request = new AddAttachmentRequest();
mockDocument = mock(PDDocument.class); mockDocument = mock(PDDocument.class);
modifiedMockDocument = mock(PDDocument.class); modifiedMockDocument = mock(PDDocument.class);
@ -60,13 +62,21 @@ class AttachmentControllerTest {
List<MultipartFile> attachments = List.of(attachment1, attachment2); List<MultipartFile> attachments = List.of(attachment1, attachment2);
request.setAttachments(attachments); request.setAttachments(attachments);
request.setFileInput(pdfFile); request.setFileInput(pdfFile);
ResponseEntity<byte[]> expectedResponse = ResponseEntity.ok("modified PDF content".getBytes()); ResponseEntity<byte[]> expectedResponse =
ResponseEntity.ok("modified PDF content".getBytes());
when(pdfDocumentFactory.load(pdfFile, false)).thenReturn(mockDocument); when(pdfDocumentFactory.load(pdfFile, false)).thenReturn(mockDocument);
when(pdfAttachmentService.addAttachment(mockDocument, attachments)).thenReturn(modifiedMockDocument); when(pdfAttachmentService.addAttachment(mockDocument, attachments))
.thenReturn(modifiedMockDocument);
try (MockedStatic<WebResponseUtils> mockedWebResponseUtils = mockStatic(WebResponseUtils.class)) { try (MockedStatic<WebResponseUtils> mockedWebResponseUtils =
mockedWebResponseUtils.when(() -> WebResponseUtils.pdfDocToWebResponse(eq(modifiedMockDocument), eq("test_with_attachments.pdf"))) mockStatic(WebResponseUtils.class)) {
mockedWebResponseUtils
.when(
() ->
WebResponseUtils.pdfDocToWebResponse(
eq(modifiedMockDocument),
eq("test_with_attachments.pdf")))
.thenReturn(expectedResponse); .thenReturn(expectedResponse);
ResponseEntity<byte[]> response = attachmentController.addAttachments(request); ResponseEntity<byte[]> response = attachmentController.addAttachments(request);
@ -84,13 +94,21 @@ class AttachmentControllerTest {
List<MultipartFile> attachments = List.of(attachment1); List<MultipartFile> attachments = List.of(attachment1);
request.setAttachments(attachments); request.setAttachments(attachments);
request.setFileInput(pdfFile); request.setFileInput(pdfFile);
ResponseEntity<byte[]> expectedResponse = ResponseEntity.ok("modified PDF content".getBytes()); ResponseEntity<byte[]> expectedResponse =
ResponseEntity.ok("modified PDF content".getBytes());
when(pdfDocumentFactory.load(pdfFile, false)).thenReturn(mockDocument); when(pdfDocumentFactory.load(pdfFile, false)).thenReturn(mockDocument);
when(pdfAttachmentService.addAttachment(mockDocument, attachments)).thenReturn(modifiedMockDocument); when(pdfAttachmentService.addAttachment(mockDocument, attachments))
.thenReturn(modifiedMockDocument);
try (MockedStatic<WebResponseUtils> mockedWebResponseUtils = mockStatic(WebResponseUtils.class)) { try (MockedStatic<WebResponseUtils> mockedWebResponseUtils =
mockedWebResponseUtils.when(() -> WebResponseUtils.pdfDocToWebResponse(eq(modifiedMockDocument), eq("test_with_attachments.pdf"))) mockStatic(WebResponseUtils.class)) {
mockedWebResponseUtils
.when(
() ->
WebResponseUtils.pdfDocToWebResponse(
eq(modifiedMockDocument),
eq("test_with_attachments.pdf")))
.thenReturn(expectedResponse); .thenReturn(expectedResponse);
ResponseEntity<byte[]> response = attachmentController.addAttachments(request); ResponseEntity<byte[]> response = attachmentController.addAttachments(request);

2
app/core/src/test/java/stirling/software/SPDF/controller/api/pipeline/PipelineProcessorTest.java
View File

@ -20,11 +20,11 @@ import org.springframework.http.ResponseEntity;
import jakarta.servlet.ServletContext; import jakarta.servlet.ServletContext;
import stirling.software.common.service.UserServiceInterface;
import stirling.software.SPDF.model.PipelineConfig; import stirling.software.SPDF.model.PipelineConfig;
import stirling.software.SPDF.model.PipelineOperation; import stirling.software.SPDF.model.PipelineOperation;
import stirling.software.SPDF.model.PipelineResult; import stirling.software.SPDF.model.PipelineResult;
import stirling.software.SPDF.service.ApiDocService; import stirling.software.SPDF.service.ApiDocService;
import stirling.software.common.service.UserServiceInterface;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
class PipelineProcessorTest { class PipelineProcessorTest {

24
app/core/src/test/java/stirling/software/SPDF/service/AttachmentServiceTest.java
View File

@ -1,15 +1,17 @@
package stirling.software.SPDF.service; package stirling.software.SPDF.service;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.io.ByteArrayInputStream; import java.io.ByteArrayInputStream;
import java.io.IOException; import java.io.IOException;
import java.util.List; import java.util.List;
import org.apache.pdfbox.pdmodel.PDDocument; import org.apache.pdfbox.pdmodel.PDDocument;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
class AttachmentServiceTest { class AttachmentServiceTest {
@ -27,8 +29,8 @@ class AttachmentServiceTest {
var attachments = List.of(mock(MultipartFile.class)); var attachments = List.of(mock(MultipartFile.class));
when(attachments.get(0).getOriginalFilename()).thenReturn("test.txt"); when(attachments.get(0).getOriginalFilename()).thenReturn("test.txt");
when(attachments.get(0).getInputStream()).thenReturn( when(attachments.get(0).getInputStream())
new ByteArrayInputStream("Test content".getBytes())); .thenReturn(new ByteArrayInputStream("Test content".getBytes()));
when(attachments.get(0).getSize()).thenReturn(12L); when(attachments.get(0).getSize()).thenReturn(12L);
when(attachments.get(0).getContentType()).thenReturn("text/plain"); when(attachments.get(0).getContentType()).thenReturn("text/plain");
@ -49,14 +51,14 @@ class AttachmentServiceTest {
var attachments = List.of(attachment1, attachment2); var attachments = List.of(attachment1, attachment2);
when(attachment1.getOriginalFilename()).thenReturn("document.pdf"); when(attachment1.getOriginalFilename()).thenReturn("document.pdf");
when(attachment1.getInputStream()).thenReturn( when(attachment1.getInputStream())
new ByteArrayInputStream("PDF content".getBytes())); .thenReturn(new ByteArrayInputStream("PDF content".getBytes()));
when(attachment1.getSize()).thenReturn(15L); when(attachment1.getSize()).thenReturn(15L);
when(attachment1.getContentType()).thenReturn("application/pdf"); when(attachment1.getContentType()).thenReturn("application/pdf");
when(attachment2.getOriginalFilename()).thenReturn("image.jpg"); when(attachment2.getOriginalFilename()).thenReturn("image.jpg");
when(attachment2.getInputStream()).thenReturn( when(attachment2.getInputStream())
new ByteArrayInputStream("Image content".getBytes())); .thenReturn(new ByteArrayInputStream("Image content".getBytes()));
when(attachment2.getSize()).thenReturn(20L); when(attachment2.getSize()).thenReturn(20L);
when(attachment2.getContentType()).thenReturn("image/jpeg"); when(attachment2.getContentType()).thenReturn("image/jpeg");
@ -74,8 +76,8 @@ class AttachmentServiceTest {
var attachments = List.of(mock(MultipartFile.class)); var attachments = List.of(mock(MultipartFile.class));
when(attachments.get(0).getOriginalFilename()).thenReturn("image.jpg"); when(attachments.get(0).getOriginalFilename()).thenReturn("image.jpg");
when(attachments.get(0).getInputStream()).thenReturn( when(attachments.get(0).getInputStream())
new ByteArrayInputStream("Image content".getBytes())); .thenReturn(new ByteArrayInputStream("Image content".getBytes()));
when(attachments.get(0).getSize()).thenReturn(25L); when(attachments.get(0).getSize()).thenReturn(25L);
when(attachments.get(0).getContentType()).thenReturn(""); when(attachments.get(0).getContentType()).thenReturn("");

2
app/core/src/test/java/stirling/software/SPDF/service/SignatureServiceTest.java
View File

@ -17,8 +17,8 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir; import org.junit.jupiter.api.io.TempDir;
import org.mockito.MockedStatic; import org.mockito.MockedStatic;
import stirling.software.common.configuration.InstallationPathConfig;
import stirling.software.SPDF.model.SignatureFile; import stirling.software.SPDF.model.SignatureFile;
import stirling.software.common.configuration.InstallationPathConfig;
class SignatureServiceTest { class SignatureServiceTest {

104
app/core/src/test/java/stirling/software/common/controller/JobControllerTest.java
View File

@ -12,36 +12,28 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations; import org.mockito.MockitoAnnotations;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpSession; import org.springframework.mock.web.MockHttpSession;
import jakarta.servlet.http.HttpServletRequest; import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpSession;
import stirling.software.common.model.job.JobResult; import stirling.software.common.model.job.JobResult;
import stirling.software.common.model.job.JobStats;
import stirling.software.common.model.job.ResultFile;
import stirling.software.common.service.FileStorage; import stirling.software.common.service.FileStorage;
import stirling.software.common.service.JobQueue; import stirling.software.common.service.JobQueue;
import stirling.software.common.service.TaskManager; import stirling.software.common.service.TaskManager;
class JobControllerTest { class JobControllerTest {
@Mock @Mock private TaskManager taskManager;
private TaskManager taskManager;
@Mock @Mock private FileStorage fileStorage;
private FileStorage fileStorage;
@Mock @Mock private JobQueue jobQueue;
private JobQueue jobQueue;
@Mock @Mock private HttpServletRequest request;
private HttpServletRequest request;
private MockHttpSession session; private MockHttpSession session;
@InjectMocks @InjectMocks private JobController controller;
private JobController controller;
@BeforeEach @BeforeEach
void setUp() { void setUp() {
@ -139,7 +131,8 @@ class JobControllerTest {
JobResult mockResult = new JobResult(); JobResult mockResult = new JobResult();
mockResult.setJobId(jobId); mockResult.setJobId(jobId);
mockResult.completeWithSingleFile(fileId, originalFileName, contentType, fileContent.length); mockResult.completeWithSingleFile(
fileId, originalFileName, contentType, fileContent.length);
when(taskManager.getJobResult(jobId)).thenReturn(mockResult); when(taskManager.getJobResult(jobId)).thenReturn(mockResult);
when(fileStorage.retrieveBytes(fileId)).thenReturn(fileContent); when(fileStorage.retrieveBytes(fileId)).thenReturn(fileContent);
@ -150,7 +143,8 @@ class JobControllerTest {
// Assert // Assert
assertEquals(HttpStatus.OK, response.getStatusCode()); assertEquals(HttpStatus.OK, response.getStatusCode());
assertEquals(contentType, response.getHeaders().getFirst("Content-Type")); assertEquals(contentType, response.getHeaders().getFirst("Content-Type"));
assertTrue(response.getHeaders().getFirst("Content-Disposition").contains(originalFileName)); assertTrue(
response.getHeaders().getFirst("Content-Disposition").contains(originalFileName));
assertEquals(fileContent, response.getBody()); assertEquals(fileContent, response.getBody());
} }
@ -229,45 +223,45 @@ class JobControllerTest {
assertTrue(response.getBody().toString().contains("Error retrieving file")); assertTrue(response.getBody().toString().contains("Error retrieving file"));
} }
/* /*
* @Test void testGetJobStats() { // Arrange JobStats mockStats = * @Test void testGetJobStats() { // Arrange JobStats mockStats =
* JobStats.builder() .totalJobs(10) .activeJobs(3) .completedJobs(7) .build(); * JobStats.builder() .totalJobs(10) .activeJobs(3) .completedJobs(7) .build();
* *
* when(taskManager.getJobStats()).thenReturn(mockStats); * when(taskManager.getJobStats()).thenReturn(mockStats);
* *
* // Act ResponseEntity<?> response = controller.getJobStats(); * // Act ResponseEntity<?> response = controller.getJobStats();
* *
* // Assert assertEquals(HttpStatus.OK, response.getStatusCode()); * // Assert assertEquals(HttpStatus.OK, response.getStatusCode());
* assertEquals(mockStats, response.getBody()); } * assertEquals(mockStats, response.getBody()); }
* *
* @Test void testCleanupOldJobs() { // Arrange when(taskManager.getJobStats()) * @Test void testCleanupOldJobs() { // Arrange when(taskManager.getJobStats())
* .thenReturn(JobStats.builder().totalJobs(10).build()) * .thenReturn(JobStats.builder().totalJobs(10).build())
* .thenReturn(JobStats.builder().totalJobs(7).build()); * .thenReturn(JobStats.builder().totalJobs(7).build());
* *
* // Act ResponseEntity<?> response = controller.cleanupOldJobs(); * // Act ResponseEntity<?> response = controller.cleanupOldJobs();
* *
* // Assert assertEquals(HttpStatus.OK, response.getStatusCode()); * // Assert assertEquals(HttpStatus.OK, response.getStatusCode());
* *
* @SuppressWarnings("unchecked") Map<String, Object> responseBody = * @SuppressWarnings("unchecked") Map<String, Object> responseBody =
* (Map<String, Object>) response.getBody(); assertEquals("Cleanup complete", * (Map<String, Object>) response.getBody(); assertEquals("Cleanup complete",
* responseBody.get("message")); assertEquals(3, * responseBody.get("message")); assertEquals(3,
* responseBody.get("removedJobs")); assertEquals(7, * responseBody.get("removedJobs")); assertEquals(7,
* responseBody.get("remainingJobs")); * responseBody.get("remainingJobs"));
* *
* verify(taskManager).cleanupOldJobs(); } * verify(taskManager).cleanupOldJobs(); }
* *
* @Test void testGetQueueStats() { // Arrange Map<String, Object> * @Test void testGetQueueStats() { // Arrange Map<String, Object>
* mockQueueStats = Map.of( "queuedJobs", 5, "queueCapacity", 10, * mockQueueStats = Map.of( "queuedJobs", 5, "queueCapacity", 10,
* "resourceStatus", "OK" ); * "resourceStatus", "OK" );
* *
* when(jobQueue.getQueueStats()).thenReturn(mockQueueStats); * when(jobQueue.getQueueStats()).thenReturn(mockQueueStats);
* *
* // Act ResponseEntity<?> response = controller.getQueueStats(); * // Act ResponseEntity<?> response = controller.getQueueStats();
* *
* // Assert assertEquals(HttpStatus.OK, response.getStatusCode()); * // Assert assertEquals(HttpStatus.OK, response.getStatusCode());
* assertEquals(mockQueueStats, response.getBody()); * assertEquals(mockQueueStats, response.getBody());
* verify(jobQueue).getQueueStats(); } * verify(jobQueue).getQueueStats(); }
*/ */
@Test @Test
void testCancelJob_InQueue() { void testCancelJob_InQueue() {
// Arrange // Arrange

11
app/proprietary/src/test/java/stirling/software/proprietary/security/CustomLogoutSuccessHandlerTest.java
View File

@ -1,17 +1,20 @@
package stirling.software.proprietary.security; package stirling.software.proprietary.security;
import jakarta.servlet.http.HttpServletRequest; import static org.mockito.Mockito.*;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException; import java.io.IOException;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken; import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import stirling.software.common.model.ApplicationProperties; import stirling.software.common.model.ApplicationProperties;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
class CustomLogoutSuccessHandlerTest { class CustomLogoutSuccessHandlerTest {

7
app/proprietary/src/test/java/stirling/software/proprietary/security/configuration/DatabaseConfigTest.java
View File

@ -1,6 +1,10 @@
package stirling.software.proprietary.security.configuration; package stirling.software.proprietary.security.configuration;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.when;
import javax.sql.DataSource; import javax.sql.DataSource;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
@ -8,10 +12,9 @@ import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource; import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoExtension;
import stirling.software.common.model.ApplicationProperties; import stirling.software.common.model.ApplicationProperties;
import stirling.software.common.model.exception.UnsupportedProviderException; import stirling.software.common.model.exception.UnsupportedProviderException;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
class DatabaseConfigTest { class DatabaseConfigTest {

9
app/proprietary/src/test/java/stirling/software/proprietary/security/service/EmailServiceTest.java
View File

@ -2,8 +2,10 @@ package stirling.software.proprietary.security.service;
import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail; import static org.junit.jupiter.api.Assertions.fail;
import jakarta.mail.MessagingException; import static org.mockito.Mockito.mock;
import jakarta.mail.internet.MimeMessage; import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
@ -17,9 +19,6 @@ import jakarta.mail.internet.MimeMessage;
import stirling.software.common.model.ApplicationProperties; import stirling.software.common.model.ApplicationProperties;
import stirling.software.proprietary.security.model.api.Email; import stirling.software.proprietary.security.model.api.Email;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
public class EmailServiceTest { public class EmailServiceTest {

25
app/proprietary/src/test/java/stirling/software/proprietary/security/service/TeamServiceTest.java
View File

@ -1,25 +1,26 @@
package stirling.software.proprietary.security.service; package stirling.software.proprietary.security.service;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
import java.util.Optional; import java.util.Optional;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoExtension;
import stirling.software.proprietary.model.Team; import stirling.software.proprietary.model.Team;
import stirling.software.proprietary.security.repository.TeamRepository; import stirling.software.proprietary.security.repository.TeamRepository;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
class TeamServiceTest { class TeamServiceTest {
@Mock @Mock private TeamRepository teamRepository;
private TeamRepository teamRepository;
@InjectMocks @InjectMocks private TeamService teamService;
private TeamService teamService;
@Test @Test
void getDefaultTeam() { void getDefaultTeam() {
@ -41,8 +42,7 @@ class TeamServiceTest {
defaultTeam.setId(1L); defaultTeam.setId(1L);
defaultTeam.setName(teamName); defaultTeam.setName(teamName);
when(teamRepository.findByName(teamName)) when(teamRepository.findByName(teamName)).thenReturn(Optional.empty());
.thenReturn(Optional.empty());
when(teamRepository.save(any(Team.class))).thenReturn(defaultTeam); when(teamRepository.save(any(Team.class))).thenReturn(defaultTeam);
Team result = teamService.getOrCreateDefaultTeam(); Team result = teamService.getOrCreateDefaultTeam();
@ -56,7 +56,7 @@ class TeamServiceTest {
team.setName("Eldians"); team.setName("Eldians");
when(teamRepository.findByName(TeamService.INTERNAL_TEAM_NAME)) when(teamRepository.findByName(TeamService.INTERNAL_TEAM_NAME))
.thenReturn(Optional.of(team)); .thenReturn(Optional.of(team));
Team result = teamService.getOrCreateInternalTeam(); Team result = teamService.getOrCreateInternalTeam();
@ -70,11 +70,10 @@ class TeamServiceTest {
internalTeam.setId(2L); internalTeam.setId(2L);
internalTeam.setName(teamName); internalTeam.setName(teamName);
when(teamRepository.findByName(teamName)) when(teamRepository.findByName(teamName)).thenReturn(Optional.empty());
.thenReturn(Optional.empty());
when(teamRepository.save(any(Team.class))).thenReturn(internalTeam); when(teamRepository.save(any(Team.class))).thenReturn(internalTeam);
when(teamRepository.findByName(TeamService.INTERNAL_TEAM_NAME)) when(teamRepository.findByName(TeamService.INTERNAL_TEAM_NAME))
.thenReturn(Optional.empty()); .thenReturn(Optional.empty());
Team result = teamService.getOrCreateInternalTeam(); Team result = teamService.getOrCreateInternalTeam();

68
app/proprietary/src/test/java/stirling/software/proprietary/security/service/UserServiceTest.java
View File

@ -1,8 +1,13 @@
package stirling.software.proprietary.security.service; package stirling.software.proprietary.security.service;
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 java.sql.SQLException; import java.sql.SQLException;
import java.util.Locale;
import java.util.Optional; import java.util.Optional;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
@ -11,10 +16,9 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.context.MessageSource; import org.springframework.context.MessageSource;
import org.springframework.security.crypto.password.PasswordEncoder; import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.test.context.bean.override.mockito.MockitoBean;
import stirling.software.common.model.ApplicationProperties; import stirling.software.common.model.ApplicationProperties;
import stirling.software.common.model.enumeration.Role; import stirling.software.common.model.enumeration.Role;
import stirling.software.common.model.exception.UnsupportedProviderException;
import stirling.software.proprietary.model.Team; import stirling.software.proprietary.model.Team;
import stirling.software.proprietary.security.database.repository.AuthorityRepository; import stirling.software.proprietary.security.database.repository.AuthorityRepository;
import stirling.software.proprietary.security.database.repository.UserRepository; import stirling.software.proprietary.security.database.repository.UserRepository;
@ -22,42 +26,27 @@ import stirling.software.proprietary.security.model.AuthenticationType;
import stirling.software.proprietary.security.model.User; import stirling.software.proprietary.security.model.User;
import stirling.software.proprietary.security.repository.TeamRepository; import stirling.software.proprietary.security.repository.TeamRepository;
import stirling.software.proprietary.security.session.SessionPersistentRegistry; import stirling.software.proprietary.security.session.SessionPersistentRegistry;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class) @ExtendWith(MockitoExtension.class)
class UserServiceTest { class UserServiceTest {
@Mock @Mock private UserRepository userRepository;
private UserRepository userRepository;
@Mock @Mock private TeamRepository teamRepository;
private TeamRepository teamRepository;
@Mock @Mock private AuthorityRepository authorityRepository;
private AuthorityRepository authorityRepository;
@Mock @Mock private PasswordEncoder passwordEncoder;
private PasswordEncoder passwordEncoder;
@Mock @Mock private MessageSource messageSource;
private MessageSource messageSource;
@Mock @Mock private SessionPersistentRegistry sessionPersistentRegistry;
private SessionPersistentRegistry sessionPersistentRegistry;
@Mock @Mock private DatabaseServiceInterface databaseService;
private DatabaseServiceInterface databaseService;
@Mock @Mock private ApplicationProperties.Security.OAUTH2 oauth2Properties;
private ApplicationProperties.Security.OAUTH2 oauth2Properties;
@InjectMocks @InjectMocks private UserService userService;
private UserService userService;
private Team mockTeam; private Team mockTeam;
private User mockUser; private User mockUser;
@ -146,10 +135,10 @@ class UserServiceTest {
AuthenticationType authType = AuthenticationType.WEB; AuthenticationType authType = AuthenticationType.WEB;
// When & Then // When & Then
IllegalArgumentException exception = assertThrows( IllegalArgumentException exception =
IllegalArgumentException.class, assertThrows(
() -> userService.saveUser(invalidUsername, authType) IllegalArgumentException.class,
); () -> userService.saveUser(invalidUsername, authType));
verify(userRepository, never()).save(any(User.class)); verify(userRepository, never()).save(any(User.class));
verify(databaseService, never()).exportDatabase(); verify(databaseService, never()).exportDatabase();
@ -221,10 +210,10 @@ class UserServiceTest {
AuthenticationType authType = AuthenticationType.WEB; AuthenticationType authType = AuthenticationType.WEB;
// When & Then // When & Then
IllegalArgumentException exception = assertThrows( IllegalArgumentException exception =
IllegalArgumentException.class, assertThrows(
() -> userService.saveUser(reservedUsername, authType) IllegalArgumentException.class,
); () -> userService.saveUser(reservedUsername, authType));
verify(userRepository, never()).save(any(User.class)); verify(userRepository, never()).save(any(User.class));
verify(databaseService, never()).exportDatabase(); verify(databaseService, never()).exportDatabase();
@ -237,10 +226,10 @@ class UserServiceTest {
AuthenticationType authType = AuthenticationType.WEB; AuthenticationType authType = AuthenticationType.WEB;
// When & Then // When & Then
IllegalArgumentException exception = assertThrows( IllegalArgumentException exception =
IllegalArgumentException.class, assertThrows(
() -> userService.saveUser(anonymousUsername, authType) IllegalArgumentException.class,
); () -> userService.saveUser(anonymousUsername, authType));
verify(userRepository, never()).save(any(User.class)); verify(userRepository, never()).save(any(User.class));
verify(databaseService, never()).exportDatabase(); verify(databaseService, never()).exportDatabase();
@ -313,5 +302,4 @@ class UserServiceTest {
verify(userRepository).save(any(User.class)); verify(userRepository).save(any(User.class));
verify(databaseService).exportDatabase(); verify(databaseService).exportDatabase();
} }
} }