Tests cleanup and stuff

common/build.gradle

@@ -51,5 +51,16 @@ dependencies {
     annotationProcessor "org.projectlombok:lombok:$lombokVersion"
 
     testImplementation "org.springframework.boot:spring-boot-starter-test"
+    testImplementation 'org.junit.jupiter:junit-jupiter-api'
+    testImplementation 'org.junit.jupiter:junit-jupiter-engine'
+    testImplementation 'org.mockito:mockito-core'
+    testImplementation 'org.mockito:mockito-junit-jupiter'
     testRuntimeOnly 'org.mockito:mockito-inline:5.2.0'
 }
+
+test {
+    useJUnitPlatform()
+    testLogging {
+        events "passed", "skipped", "failed"
+    }
+}

common/src/main/java/stirling/software/common/aop/AutoJobAspect.java

@@ -1,7 +1,5 @@
 package stirling.software.common.aop;
 
-import java.nio.file.Files;
-import java.nio.file.Path;
 import java.io.IOException;
 
 import org.aspectj.lang.ProceedingJoinPoint;
@@ -71,7 +69,8 @@ public class AutoJobAspect {
 
                         log.debug("Created persistent file copy with fileId: {}", fileId);
                     } catch (IOException e) {
-                        throw new RuntimeException("Failed to create persistent copy of uploaded file", e);
+                        throw new RuntimeException(
+                                "Failed to create persistent copy of uploaded file", e);
                     }
                 }
             }

common/src/main/java/stirling/software/common/controller/JobController.java

@@ -0,0 +1,114 @@
+package stirling.software.common.controller;
+
+import java.util.Map;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+import stirling.software.common.model.job.JobResult;
+import stirling.software.common.model.job.JobStats;
+import stirling.software.common.service.FileStorage;
+import stirling.software.common.service.TaskManager;
+
+/** REST controller for job-related endpoints */
+@RestController
+@RequiredArgsConstructor
+@Slf4j
+public class JobController {
+
+    private final TaskManager taskManager;
+    private final FileStorage fileStorage;
+
+    /**
+     * Get the status of a job
+     *
+     * @param jobId The job ID
+     * @return The job result
+     */
+    @GetMapping("/api/v1/general/job/{jobId}")
+    public ResponseEntity<?> getJobStatus(@PathVariable("jobId") String jobId) {
+        JobResult result = taskManager.getJobResult(jobId);
+        if (result == null) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.ok(result);
+    }
+
+    /**
+     * Get the result of a job
+     *
+     * @param jobId The job ID
+     * @return The job result
+     */
+    @GetMapping("/api/v1/general/job/{jobId}/result")
+    public ResponseEntity<?> getJobResult(@PathVariable("jobId") String jobId) {
+        JobResult result = taskManager.getJobResult(jobId);
+        if (result == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        if (!result.isComplete()) {
+            return ResponseEntity.badRequest().body("Job is not complete yet");
+        }
+
+        if (result.getError() != null) {
+            return ResponseEntity.badRequest().body("Job failed: " + result.getError());
+        }
+
+        if (result.getFileId() != null) {
+            try {
+                byte[] fileContent = fileStorage.retrieveBytes(result.getFileId());
+                return ResponseEntity.ok()
+                        .header("Content-Type", result.getContentType())
+                        .header(
+                                "Content-Disposition",
+                                "form-data; name=\"attachment\"; filename=\""
+                                        + result.getOriginalFileName()
+                                        + "\"")
+                        .body(fileContent);
+            } catch (Exception e) {
+                log.error("Error retrieving file for job {}: {}", jobId, e.getMessage(), e);
+                return ResponseEntity.internalServerError()
+                        .body("Error retrieving file: " + e.getMessage());
+            }
+        }
+
+        return ResponseEntity.ok(result.getResult());
+    }
+
+    /**
+     * Get statistics about jobs in the system
+     *
+     * @return Job statistics
+     */
+    @GetMapping("/api/v1/general/job/stats")
+    public ResponseEntity<JobStats> getJobStats() {
+        JobStats stats = taskManager.getJobStats();
+        return ResponseEntity.ok(stats);
+    }
+
+    /**
+     * Manually trigger cleanup of old jobs
+     *
+     * @return A response indicating how many jobs were cleaned up
+     */
+    @PostMapping("/api/v1/general/job/cleanup")
+    public ResponseEntity<?> cleanupOldJobs() {
+        int beforeCount = taskManager.getJobStats().getTotalJobs();
+        taskManager.cleanupOldJobs();
+        int afterCount = taskManager.getJobStats().getTotalJobs();
+        int removedCount = beforeCount - afterCount;
+
+        return ResponseEntity.ok(
+                Map.of(
+                        "message", "Cleanup complete",
+                        "removedJobs", removedCount,
+                        "remainingJobs", afterCount));
+    }
+}

common/src/main/java/stirling/software/common/model/job/JobResult.java

@@ -7,59 +7,38 @@ import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
-/**
- * Represents the result of a job execution.
- * Used by the TaskManager to store job results.
- */
+/** Represents the result of a job execution. Used by the TaskManager to store job results. */
 @Data
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor
 public class JobResult {
 
-    /**
-     * The job ID
-     */
+    /** The job ID */
     private String jobId;
 
-    /**
-     * Flag indicating if the job is complete
-     */
+    /** Flag indicating if the job is complete */
     private boolean complete;
 
-    /**
-     * Error message if the job failed
-     */
+    /** Error message if the job failed */
     private String error;
 
-    /**
-     * The file ID of the result file, if applicable
-     */
+    /** The file ID of the result file, if applicable */
     private String fileId;
 
-    /**
-     * Original file name, if applicable
-     */
+    /** Original file name, if applicable */
     private String originalFileName;
 
-    /**
-     * MIME type of the result, if applicable
-     */
+    /** MIME type of the result, if applicable */
     private String contentType;
 
-    /**
-     * Time when the job was created
-     */
+    /** Time when the job was created */
     private LocalDateTime createdAt;
 
-    /**
-     * Time when the job was completed
-     */
+    /** Time when the job was completed */
     private LocalDateTime completedAt;
 
-    /**
-     * The actual result object, if not a file
-     */
+    /** The actual result object, if not a file */
     private Object result;
 
     /**

common/src/main/java/stirling/software/common/model/job/JobStats.java

@@ -0,0 +1,43 @@
+package stirling.software.common.model.job;
+
+import java.time.LocalDateTime;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/** Represents statistics about jobs in the system */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class JobStats {
+
+    /** Total number of jobs (active and completed) */
+    private int totalJobs;
+
+    /** Number of active (incomplete) jobs */
+    private int activeJobs;
+
+    /** Number of completed jobs */
+    private int completedJobs;
+
+    /** Number of failed jobs */
+    private int failedJobs;
+
+    /** Number of successful jobs */
+    private int successfulJobs;
+
+    /** Number of jobs with file results */
+    private int fileResultJobs;
+
+    /** The oldest active job's creation timestamp */
+    private LocalDateTime oldestActiveJobTime;
+
+    /** The newest active job's creation timestamp */
+    private LocalDateTime newestActiveJobTime;
+
+    /** The average processing time for completed jobs in milliseconds */
+    private long averageProcessingTimeMs;
+}

common/src/main/java/stirling/software/common/service/FileStorage.java

@@ -13,8 +13,8 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
 /**
- * Service for storing and retrieving files with unique file IDs.
- * Used by the AutoJobPostMapping system to handle file references.
+ * Service for storing and retrieving files with unique file IDs. Used by the AutoJobPostMapping
+ * system to handle file references.
  */
 @Service
 @RequiredArgsConstructor

common/src/main/java/stirling/software/common/service/JobExecutorService.java

@@ -4,33 +4,50 @@ import java.io.IOException;
 import java.util.UUID;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.function.Supplier;
 
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 
-import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
 import stirling.software.common.controller.WebSocketProgressController;
 import stirling.software.common.model.job.JobProgress;
 import stirling.software.common.model.job.JobResponse;
 
-/**
- * Service for executing jobs asynchronously or synchronously
- */
+/** Service for executing jobs asynchronously or synchronously */
 @Service
-@RequiredArgsConstructor
 @Slf4j
 public class JobExecutorService {
 
     private final TaskManager taskManager;
     private final WebSocketProgressController webSocketSender;
     private final FileStorage fileStorage;
-    private final ExecutorService executor = Executors.newCachedThreadPool();
+    private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
+    private final long effectiveTimeoutMs;
+
+    public JobExecutorService(
+            TaskManager taskManager,
+            WebSocketProgressController webSocketSender,
+            FileStorage fileStorage,
+            @Value("${spring.mvc.async.request-timeout:1200000}") long asyncRequestTimeoutMs,
+            @Value("${server.servlet.session.timeout:30m}") String sessionTimeout) {
+        this.taskManager = taskManager;
+        this.webSocketSender = webSocketSender;
+        this.fileStorage = fileStorage;
+
+        // Parse session timeout and calculate effective timeout once during initialization
+        long sessionTimeoutMs = parseSessionTimeout(sessionTimeout);
+        this.effectiveTimeoutMs = Math.min(asyncRequestTimeoutMs, sessionTimeoutMs);
+        log.info(
+                "Job executor configured with effective timeout of {} ms", this.effectiveTimeoutMs);
+    }
 
     /**
      * Run a job either asynchronously or synchronously
@@ -50,10 +67,22 @@ public class JobExecutorService {
             executor.execute(
                     () -> {
                         try {
-                            Object result = work.get();
+                            log.debug(
+                                    "Running async job {} with timeout {} ms",
+                                    jobId,
+                                    effectiveTimeoutMs);
+
+                            // Execute with timeout
+                            Object result =
+                                    executeWithTimeout(() -> work.get(), effectiveTimeoutMs);
                             processJobResult(jobId, result);
                             webSocketSender.sendProgress(
                                     jobId, new JobProgress(jobId, "Done", 100, "Complete"));
+                        } catch (TimeoutException te) {
+                            log.error("Job {} timed out after {} ms", jobId, effectiveTimeoutMs);
+                            taskManager.setError(jobId, "Job timed out");
+                            webSocketSender.sendProgress(
+                                    jobId, new JobProgress(jobId, "Error", 100, "Job timed out"));
                         } catch (Exception e) {
                             log.error("Error executing job {}: {}", jobId, e.getMessage(), e);
                             taskManager.setError(jobId, e.getMessage());
@@ -65,7 +94,10 @@ public class JobExecutorService {
             return ResponseEntity.ok().body(new JobResponse<>(true, jobId, null));
         } else {
             try {
-                Object result = work.get();
+                log.debug("Running sync job with timeout {} ms", effectiveTimeoutMs);
+
+                // Execute with timeout
+                Object result = executeWithTimeout(() -> work.get(), effectiveTimeoutMs);
 
                 // If the result is already a ResponseEntity, return it directly
                 if (result instanceof ResponseEntity) {
@@ -74,6 +106,10 @@ public class JobExecutorService {
 
                 // Process different result types
                 return handleResultForSyncJob(result);
+            } catch (TimeoutException te) {
+                log.error("Synchronous job timed out after {} ms", effectiveTimeoutMs);
+                return ResponseEntity.internalServerError()
+                        .body("Job timed out after " + effectiveTimeoutMs + " ms");
             } catch (Exception e) {
                 log.error("Error executing synchronous job: {}", e.getMessage(), e);
                 return ResponseEntity.internalServerError().body("Job failed: " + e.getMessage());
@@ -104,11 +140,13 @@ public class JobExecutorService {
                     String contentType = "application/pdf";
 
                     if (response.getHeaders().getContentDisposition() != null) {
-                        String disposition = response.getHeaders().getContentDisposition().toString();
+                        String disposition =
+                                response.getHeaders().getContentDisposition().toString();
                         if (disposition.contains("filename=")) {
-                            filename = disposition.substring(
-                                    disposition.indexOf("filename=") + 9, 
-                                    disposition.lastIndexOf("\""));
+                            filename =
+                                    disposition.substring(
+                                            disposition.indexOf("filename=") + 9,
+                                            disposition.lastIndexOf("\""));
                         }
                     }
 
@@ -124,7 +162,8 @@ public class JobExecutorService {
                     if (body != null && body.toString().contains("fileId")) {
                         try {
                             // Try to extract fileId using reflection
-                            java.lang.reflect.Method getFileId = body.getClass().getMethod("getFileId");
+                            java.lang.reflect.Method getFileId =
+                                    body.getClass().getMethod("getFileId");
                             String fileId = (String) getFileId.invoke(body);
 
                             if (fileId != null && !fileId.isEmpty()) {
@@ -133,17 +172,20 @@ public class JobExecutorService {
                                 String contentType = "application/pdf";
 
                                 try {
-                                    java.lang.reflect.Method getOriginalFileName = body.getClass().getMethod("getOriginalFilename");
+                                    java.lang.reflect.Method getOriginalFileName =
+                                            body.getClass().getMethod("getOriginalFilename");
                                     String origName = (String) getOriginalFileName.invoke(body);
                                     if (origName != null && !origName.isEmpty()) {
                                         filename = origName;
                                     }
                                 } catch (Exception e) {
-                                    log.debug("Could not get original filename: {}", e.getMessage());
+                                    log.debug(
+                                            "Could not get original filename: {}", e.getMessage());
                                 }
 
                                 try {
-                                    java.lang.reflect.Method getContentType = body.getClass().getMethod("getContentType");
+                                    java.lang.reflect.Method getContentType =
+                                            body.getClass().getMethod("getContentType");
                                     String ct = (String) getContentType.invoke(body);
                                     if (ct != null && !ct.isEmpty()) {
                                         contentType = ct;
@@ -159,7 +201,9 @@ public class JobExecutorService {
                                 return;
                             }
                         } catch (Exception e) {
-                            log.debug("Failed to extract fileId from response body: {}", e.getMessage());
+                            log.debug(
+                                    "Failed to extract fileId from response body: {}",
+                                    e.getMessage());
                         }
                     }
 
@@ -170,17 +214,15 @@ public class JobExecutorService {
                 MultipartFile file = (MultipartFile) result;
                 String fileId = fileStorage.storeFile(file);
                 taskManager.setFileResult(
-                        jobId, 
-                        fileId, 
-                        file.getOriginalFilename(), 
-                        file.getContentType());
+                        jobId, fileId, file.getOriginalFilename(), file.getContentType());
                 log.debug("Stored MultipartFile result with fileId: {}", fileId);
             } else {
                 // Check if result has a fileId field
                 if (result != null) {
                     try {
                         // Try to extract fileId using reflection
-                        java.lang.reflect.Method getFileId = result.getClass().getMethod("getFileId");
+                        java.lang.reflect.Method getFileId =
+                                result.getClass().getMethod("getFileId");
                         String fileId = (String) getFileId.invoke(result);
 
                         if (fileId != null && !fileId.isEmpty()) {
@@ -189,7 +231,8 @@ public class JobExecutorService {
                             String contentType = "application/pdf";
 
                             try {
-                                java.lang.reflect.Method getOriginalFileName = result.getClass().getMethod("getOriginalFilename");
+                                java.lang.reflect.Method getOriginalFileName =
+                                        result.getClass().getMethod("getOriginalFilename");
                                 String origName = (String) getOriginalFileName.invoke(result);
                                 if (origName != null && !origName.isEmpty()) {
                                     filename = origName;
@@ -199,7 +242,8 @@ public class JobExecutorService {
                             }
 
                             try {
-                                java.lang.reflect.Method getContentType = result.getClass().getMethod("getContentType");
+                                java.lang.reflect.Method getContentType =
+                                        result.getClass().getMethod("getContentType");
                                 String ct = (String) getContentType.invoke(result);
                                 if (ct != null && !ct.isEmpty()) {
                                     contentType = ct;
@@ -215,7 +259,8 @@ public class JobExecutorService {
                             return;
                         }
                     } catch (Exception e) {
-                        log.debug("Failed to extract fileId from result object: {}", e.getMessage());
+                        log.debug(
+                                "Failed to extract fileId from result object: {}", e.getMessage());
                     }
                 }
 
@@ -242,7 +287,8 @@ public class JobExecutorService {
             // Return byte array as PDF
             return ResponseEntity.ok()
                     .contentType(MediaType.APPLICATION_PDF)
-                    .header(HttpHeaders.CONTENT_DISPOSITION, 
+                    .header(
+                            HttpHeaders.CONTENT_DISPOSITION,
                             "form-data; name=\"attachment\"; filename=\"result.pdf\"")
                     .body(result);
         } else if (result instanceof MultipartFile) {
@@ -250,13 +296,74 @@ public class JobExecutorService {
             MultipartFile file = (MultipartFile) result;
             return ResponseEntity.ok()
                     .contentType(MediaType.parseMediaType(file.getContentType()))
-                    .header(HttpHeaders.CONTENT_DISPOSITION, 
-                            "form-data; name=\"attachment\"; filename=\"" + 
-                                    file.getOriginalFilename() + "\"")
+                    .header(
+                            HttpHeaders.CONTENT_DISPOSITION,
+                            "form-data; name=\"attachment\"; filename=\""
+                                    + file.getOriginalFilename()
+                                    + "\"")
                     .body(file.getBytes());
         } else {
             // Default case: return as JSON
             return ResponseEntity.ok(result);
         }
     }
+
+    /**
+     * Parse session timeout string (e.g., "30m", "1h") to milliseconds
+     *
+     * @param timeout The timeout string
+     * @return The timeout in milliseconds
+     */
+    private long parseSessionTimeout(String timeout) {
+        if (timeout == null || timeout.isEmpty()) {
+            return 30 * 60 * 1000; // Default: 30 minutes
+        }
+
+        try {
+            String value = timeout.replaceAll("[^\\d.]", "");
+            String unit = timeout.replaceAll("[\\d.]", "");
+
+            double numericValue = Double.parseDouble(value);
+
+            return switch (unit.toLowerCase()) {
+                case "s" -> (long) (numericValue * 1000);
+                case "m" -> (long) (numericValue * 60 * 1000);
+                case "h" -> (long) (numericValue * 60 * 60 * 1000);
+                case "d" -> (long) (numericValue * 24 * 60 * 60 * 1000);
+                default -> (long) (numericValue * 60 * 1000); // Default to minutes
+            };
+        } catch (Exception e) {
+            log.warn("Could not parse session timeout '{}', using default", timeout);
+            return 30 * 60 * 1000; // Default: 30 minutes
+        }
+    }
+
+    /**
+     * Execute a supplier with a timeout
+     *
+     * @param supplier The supplier to execute
+     * @param timeoutMs The timeout in milliseconds
+     * @return The result from the supplier
+     * @throws TimeoutException If the execution times out
+     * @throws Exception If the supplier throws an exception
+     */
+    private <T> T executeWithTimeout(Supplier<T> supplier, long timeoutMs)
+            throws TimeoutException, Exception {
+        java.util.concurrent.CompletableFuture<T> future =
+                java.util.concurrent.CompletableFuture.supplyAsync(supplier);
+
+        try {
+            return future.get(timeoutMs, TimeUnit.MILLISECONDS);
+        } catch (java.util.concurrent.TimeoutException e) {
+            future.cancel(true);
+            throw new TimeoutException("Execution timed out after " + timeoutMs + " ms");
+        } catch (java.util.concurrent.ExecutionException e) {
+            throw (Exception) e.getCause();
+        } catch (java.util.concurrent.CancellationException e) {
+            throw new Exception("Execution was cancelled", e);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new Exception("Execution was interrupted", e);
+        }
+    }
 }

common/src/main/java/stirling/software/common/service/TaskManager.java

@@ -1,25 +1,25 @@
 package stirling.software.common.service;
 
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 
 import org.springframework.beans.factory.annotation.Value;
-import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RestController;
 
-import lombok.RequiredArgsConstructor;
+import jakarta.annotation.PreDestroy;
+
 import lombok.extern.slf4j.Slf4j;
 
 import stirling.software.common.model.job.JobResult;
+import stirling.software.common.model.job.JobStats;
 
-/**
- * Manages async tasks and their results
- */
+/** Manages async tasks and their results */
 @Service
-@RequiredArgsConstructor
 @Slf4j
 public class TaskManager {
     private final Map<String, JobResult> jobResults = new ConcurrentHashMap<>();
@@ -28,6 +28,24 @@ public class TaskManager {
     private int jobResultExpiryMinutes = 30;
 
     private final FileStorage fileStorage;
+    private final ScheduledExecutorService cleanupExecutor =
+            Executors.newSingleThreadScheduledExecutor();
+
+    /** Initialize the task manager and start the cleanup scheduler */
+    public TaskManager(FileStorage fileStorage) {
+        this.fileStorage = fileStorage;
+
+        // Schedule periodic cleanup of old job results
+        cleanupExecutor.scheduleAtFixedRate(
+                this::cleanupOldJobs,
+                10, // Initial delay
+                10, // Interval
+                TimeUnit.MINUTES);
+
+        log.info(
+                "Task manager initialized with job result expiry of {} minutes",
+                jobResultExpiryMinutes);
+    }
 
     /**
      * Create a new task with the given job ID
@@ -59,7 +77,8 @@ public class TaskManager {
      * @param originalFileName The original file name
      * @param contentType The content type of the file
      */
-    public void setFileResult(String jobId, String fileId, String originalFileName, String contentType) {
+    public void setFileResult(
+            String jobId, String fileId, String originalFileName, String contentType) {
         JobResult jobResult = getOrCreateJobResult(jobId);
         jobResult.completeWithFile(fileId, originalFileName, contentType);
         log.debug("Set file result for job ID: {} with file ID: {}", jobId, fileId);
@@ -84,7 +103,9 @@ public class TaskManager {
      */
     public void setComplete(String jobId) {
         JobResult jobResult = getOrCreateJobResult(jobId);
-        if (jobResult.getResult() == null && jobResult.getFileId() == null && jobResult.getError() == null) {
+        if (jobResult.getResult() == null
+                && jobResult.getFileId() == null
+                && jobResult.getError() == null) {
             // If no result or error has been set, mark it as complete with an empty result
             jobResult.completeWithResult("Task completed successfully");
         }
@@ -112,6 +133,79 @@ public class TaskManager {
         return jobResults.get(jobId);
     }
 
+    /**
+     * Get statistics about all jobs in the system
+     *
+     * @return Job statistics
+     */
+    public JobStats getJobStats() {
+        int totalJobs = jobResults.size();
+        int activeJobs = 0;
+        int completedJobs = 0;
+        int failedJobs = 0;
+        int successfulJobs = 0;
+        int fileResultJobs = 0;
+
+        LocalDateTime oldestActiveJobTime = null;
+        LocalDateTime newestActiveJobTime = null;
+        long totalProcessingTimeMs = 0;
+
+        for (JobResult result : jobResults.values()) {
+            if (result.isComplete()) {
+                completedJobs++;
+
+                // Calculate processing time for completed jobs
+                if (result.getCreatedAt() != null && result.getCompletedAt() != null) {
+                    long processingTimeMs =
+                            java.time.Duration.between(
+                                            result.getCreatedAt(), result.getCompletedAt())
+                                    .toMillis();
+                    totalProcessingTimeMs += processingTimeMs;
+                }
+
+                if (result.getError() != null) {
+                    failedJobs++;
+                } else {
+                    successfulJobs++;
+                    if (result.getFileId() != null) {
+                        fileResultJobs++;
+                    }
+                }
+            } else {
+                activeJobs++;
+
+                // Track oldest and newest active jobs
+                if (result.getCreatedAt() != null) {
+                    if (oldestActiveJobTime == null
+                            || result.getCreatedAt().isBefore(oldestActiveJobTime)) {
+                        oldestActiveJobTime = result.getCreatedAt();
+                    }
+
+                    if (newestActiveJobTime == null
+                            || result.getCreatedAt().isAfter(newestActiveJobTime)) {
+                        newestActiveJobTime = result.getCreatedAt();
+                    }
+                }
+            }
+        }
+
+        // Calculate average processing time
+        long averageProcessingTimeMs =
+                completedJobs > 0 ? totalProcessingTimeMs / completedJobs : 0;
+
+        return JobStats.builder()
+                .totalJobs(totalJobs)
+                .activeJobs(activeJobs)
+                .completedJobs(completedJobs)
+                .failedJobs(failedJobs)
+                .successfulJobs(successfulJobs)
+                .fileResultJobs(fileResultJobs)
+                .oldestActiveJobTime(oldestActiveJobTime)
+                .newestActiveJobTime(newestActiveJobTime)
+                .averageProcessingTimeMs(averageProcessingTimeMs)
+                .build();
+    }
+
     /**
      * Get or create a job result
      *
@@ -122,65 +216,59 @@ public class TaskManager {
         return jobResults.computeIfAbsent(jobId, JobResult::createNew);
     }
 
-    /**
-     * REST controller for job-related endpoints
-     */
-    @RestController
-    public class JobController {
+    /** Clean up old completed job results */
+    public void cleanupOldJobs() {
+        LocalDateTime expiryThreshold =
+                LocalDateTime.now().minus(jobResultExpiryMinutes, ChronoUnit.MINUTES);
+        int removedCount = 0;
 
-        /**
-         * Get the status of a job
-         * 
-         * @param jobId The job ID
-         * @return The job result
-         */
-        @GetMapping("/api/v1/general/job/{jobId}")
-        public ResponseEntity<?> getJobStatus(@PathVariable("jobId") String jobId) {
-            JobResult result = jobResults.get(jobId);
-            if (result == null) {
-                return ResponseEntity.notFound().build();
-            }
-            return ResponseEntity.ok(result);
-        }
+        try {
+            for (Map.Entry<String, JobResult> entry : jobResults.entrySet()) {
+                JobResult result = entry.getValue();
 
-        /**
-         * Get the result of a job
-         * 
-         * @param jobId The job ID
-         * @return The job result
-         */
-        @GetMapping("/api/v1/general/job/{jobId}/result")
-        public ResponseEntity<?> getJobResult(@PathVariable("jobId") String jobId) {
-            JobResult result = jobResults.get(jobId);
-            if (result == null) {
-                return ResponseEntity.notFound().build();
-            }
+                // Remove completed jobs that are older than the expiry threshold
+                if (result.isComplete()
+                        && result.getCompletedAt() != null
+                        && result.getCompletedAt().isBefore(expiryThreshold)) {
 
-            if (!result.isComplete()) {
-                return ResponseEntity.badRequest().body("Job is not complete yet");
-            }
+                    // If the job has a file result, delete the file
+                    if (result.getFileId() != null) {
+                        try {
+                            fileStorage.deleteFile(result.getFileId());
+                        } catch (Exception e) {
+                            log.warn(
+                                    "Failed to delete file for job {}: {}",
+                                    entry.getKey(),
+                                    e.getMessage());
+                        }
+                    }
 
-            if (result.getError() != null) {
-                return ResponseEntity.badRequest().body("Job failed: " + result.getError());
-            }
-            
-            if (result.getFileId() != null) {
-                try {
-                    byte[] fileContent = fileStorage.retrieveBytes(result.getFileId());
-                    return ResponseEntity.ok()
-                            .header("Content-Type", result.getContentType())
-                            .header("Content-Disposition", 
-                                    "form-data; name=\"attachment\"; filename=\"" + 
-                                    result.getOriginalFileName() + "\"")
-                            .body(fileContent);
-                } catch (Exception e) {
-                    log.error("Error retrieving file for job {}: {}", jobId, e.getMessage(), e);
-                    return ResponseEntity.internalServerError()
-                            .body("Error retrieving file: " + e.getMessage());
+                    // Remove the job result
+                    jobResults.remove(entry.getKey());
+                    removedCount++;
                 }
             }
 
-            return ResponseEntity.ok(result.getResult());
+            if (removedCount > 0) {
+                log.info("Cleaned up {} expired job results", removedCount);
+            }
+        } catch (Exception e) {
+            log.error("Error during job cleanup: {}", e.getMessage(), e);
+        }
+    }
+
+    /** Shutdown the cleanup executor */
+    @PreDestroy
+    public void shutdown() {
+        try {
+            log.info("Shutting down job result cleanup executor");
+            cleanupExecutor.shutdown();
+            if (!cleanupExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
+                cleanupExecutor.shutdownNow();
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            cleanupExecutor.shutdownNow();
         }
     }
 }

common/src/test/java/stirling/software/common/controller/JobControllerTest.java

@@ -0,0 +1,227 @@
+package stirling.software.common.controller;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Map;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import stirling.software.common.model.job.JobResult;
+import stirling.software.common.model.job.JobStats;
+import stirling.software.common.service.FileStorage;
+import stirling.software.common.service.TaskManager;
+
+class JobControllerTest {
+
+    @Mock
+    private TaskManager taskManager;
+    
+    @Mock
+    private FileStorage fileStorage;
+    
+    @InjectMocks
+    private JobController controller;
+    
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+    }
+    
+    @Test
+    void testGetJobStatus_ExistingJob() {
+        // Arrange
+        String jobId = "test-job-id";
+        JobResult mockResult = new JobResult();
+        mockResult.setJobId(jobId);
+        when(taskManager.getJobResult(jobId)).thenReturn(mockResult);
+        
+        // Act
+        ResponseEntity<?> response = controller.getJobStatus(jobId);
+        
+        // Assert
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals(mockResult, response.getBody());
+    }
+    
+    @Test
+    void testGetJobStatus_NonExistentJob() {
+        // Arrange
+        String jobId = "non-existent-job";
+        when(taskManager.getJobResult(jobId)).thenReturn(null);
+        
+        // Act
+        ResponseEntity<?> response = controller.getJobStatus(jobId);
+        
+        // Assert
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+    }
+    
+    @Test
+    void testGetJobResult_CompletedSuccessfulWithObject() {
+        // Arrange
+        String jobId = "test-job-id";
+        JobResult mockResult = new JobResult();
+        mockResult.setJobId(jobId);
+        mockResult.setComplete(true);
+        String resultObject = "Test result";
+        mockResult.completeWithResult(resultObject);
+        
+        when(taskManager.getJobResult(jobId)).thenReturn(mockResult);
+        
+        // Act
+        ResponseEntity<?> response = controller.getJobResult(jobId);
+        
+        // Assert
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals(resultObject, response.getBody());
+    }
+    
+    @Test
+    void testGetJobResult_CompletedSuccessfulWithFile() throws Exception {
+        // Arrange
+        String jobId = "test-job-id";
+        String fileId = "file-id";
+        String originalFileName = "test.pdf";
+        String contentType = "application/pdf";
+        byte[] fileContent = "Test file content".getBytes();
+        
+        JobResult mockResult = new JobResult();
+        mockResult.setJobId(jobId);
+        mockResult.completeWithFile(fileId, originalFileName, contentType);
+        
+        when(taskManager.getJobResult(jobId)).thenReturn(mockResult);
+        when(fileStorage.retrieveBytes(fileId)).thenReturn(fileContent);
+        
+        // Act
+        ResponseEntity<?> response = controller.getJobResult(jobId);
+        
+        // Assert
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals(contentType, response.getHeaders().getFirst("Content-Type"));
+        assertTrue(response.getHeaders().getFirst("Content-Disposition").contains(originalFileName));
+        assertEquals(fileContent, response.getBody());
+    }
+    
+    @Test
+    void testGetJobResult_CompletedWithError() {
+        // Arrange
+        String jobId = "test-job-id";
+        String errorMessage = "Test error";
+        
+        JobResult mockResult = new JobResult();
+        mockResult.setJobId(jobId);
+        mockResult.failWithError(errorMessage);
+        
+        when(taskManager.getJobResult(jobId)).thenReturn(mockResult);
+        
+        // Act
+        ResponseEntity<?> response = controller.getJobResult(jobId);
+        
+        // Assert
+        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+        assertTrue(response.getBody().toString().contains(errorMessage));
+    }
+    
+    @Test
+    void testGetJobResult_IncompleteJob() {
+        // Arrange
+        String jobId = "test-job-id";
+        
+        JobResult mockResult = new JobResult();
+        mockResult.setJobId(jobId);
+        mockResult.setComplete(false);
+        
+        when(taskManager.getJobResult(jobId)).thenReturn(mockResult);
+        
+        // Act
+        ResponseEntity<?> response = controller.getJobResult(jobId);
+        
+        // Assert
+        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
+        assertTrue(response.getBody().toString().contains("not complete"));
+    }
+    
+    @Test
+    void testGetJobResult_NonExistentJob() {
+        // Arrange
+        String jobId = "non-existent-job";
+        when(taskManager.getJobResult(jobId)).thenReturn(null);
+        
+        // Act
+        ResponseEntity<?> response = controller.getJobResult(jobId);
+        
+        // Assert
+        assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+    }
+    
+    @Test
+    void testGetJobResult_ErrorRetrievingFile() throws Exception {
+        // Arrange
+        String jobId = "test-job-id";
+        String fileId = "file-id";
+        String originalFileName = "test.pdf";
+        String contentType = "application/pdf";
+        
+        JobResult mockResult = new JobResult();
+        mockResult.setJobId(jobId);
+        mockResult.completeWithFile(fileId, originalFileName, contentType);
+        
+        when(taskManager.getJobResult(jobId)).thenReturn(mockResult);
+        when(fileStorage.retrieveBytes(fileId)).thenThrow(new RuntimeException("File not found"));
+        
+        // Act
+        ResponseEntity<?> response = controller.getJobResult(jobId);
+        
+        // Assert
+        assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
+        assertTrue(response.getBody().toString().contains("Error retrieving file"));
+    }
+    
+    @Test
+    void testGetJobStats() {
+        // Arrange
+        JobStats mockStats = JobStats.builder()
+                .totalJobs(10)
+                .activeJobs(3)
+                .completedJobs(7)
+                .build();
+        
+        when(taskManager.getJobStats()).thenReturn(mockStats);
+        
+        // Act
+        ResponseEntity<JobStats> response = controller.getJobStats();
+        
+        // Assert
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals(mockStats, response.getBody());
+    }
+    
+    @Test
+    void testCleanupOldJobs() {
+        // Arrange
+        when(taskManager.getJobStats())
+            .thenReturn(JobStats.builder().totalJobs(10).build())
+            .thenReturn(JobStats.builder().totalJobs(7).build());
+        
+        // Act
+        ResponseEntity<?> response = controller.cleanupOldJobs();
+        
+        // Assert
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        
+        @SuppressWarnings("unchecked")
+        Map<String, Object> responseBody = (Map<String, Object>) response.getBody();
+        assertEquals("Cleanup complete", responseBody.get("message"));
+        assertEquals(3, responseBody.get("removedJobs"));
+        assertEquals(7, responseBody.get("remainingJobs"));
+        
+        verify(taskManager).cleanupOldJobs();
+    }
+}

common/src/test/java/stirling/software/common/controller/WebSocketProgressControllerTest.java

@@ -0,0 +1,69 @@
+package stirling.software.common.controller;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.messaging.simp.SimpMessagingTemplate;
+
+import stirling.software.common.model.job.JobProgress;
+
+class WebSocketProgressControllerTest {
+
+    @Mock
+    private SimpMessagingTemplate messagingTemplate;
+    
+    @InjectMocks
+    private WebSocketProgressController controller;
+    
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+    }
+    
+    @Test
+    void testSendProgress_WithMessagingTemplate() {
+        // Arrange
+        String jobId = "test-job-id";
+        JobProgress progress = new JobProgress(jobId, "In Progress", 50, "Processing");
+        
+        // Act
+        controller.sendProgress(jobId, progress);
+        
+        // Assert
+        verify(messagingTemplate).convertAndSend("/topic/progress/" + jobId, progress);
+    }
+    
+    @Test
+    void testSendProgress_WithNullMessagingTemplate() {
+        // Arrange
+        WebSocketProgressController controllerWithNullTemplate = new WebSocketProgressController();
+        String jobId = "test-job-id";
+        JobProgress progress = new JobProgress(jobId, "In Progress", 50, "Processing");
+        
+        // Act - should not throw exception even with null template
+        controllerWithNullTemplate.sendProgress(jobId, progress);
+        
+        // No assertion needed - test passes if no exception is thrown
+    }
+    
+    @Test
+    void testSetMessagingTemplate() {
+        // Arrange
+        WebSocketProgressController newController = new WebSocketProgressController();
+        SimpMessagingTemplate newTemplate = mock(SimpMessagingTemplate.class);
+        
+        // Act
+        newController.setMessagingTemplate(newTemplate);
+        String jobId = "test-job-id";
+        JobProgress progress = new JobProgress(jobId, "In Progress", 50, "Processing");
+        newController.sendProgress(jobId, progress);
+        
+        // Assert
+        verify(newTemplate).convertAndSend("/topic/progress/" + jobId, progress);
+    }
+}

common/src/test/java/stirling/software/common/service/FileStorageTest.java

@@ -0,0 +1,190 @@
+package stirling.software.common.service;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import static org.mockito.AdditionalAnswers.*;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.UUID;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.test.util.ReflectionTestUtils;
+import org.springframework.web.multipart.MultipartFile;
+
+class FileStorageTest {
+
+    @TempDir
+    Path tempDir;
+    
+    @Mock
+    private FileOrUploadService fileOrUploadService;
+    
+    @InjectMocks
+    private FileStorage fileStorage;
+    
+    private MultipartFile mockFile;
+    
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+        ReflectionTestUtils.setField(fileStorage, "tempDirPath", tempDir.toString());
+        
+        // Create a mock MultipartFile
+        mockFile = mock(MultipartFile.class);
+        when(mockFile.getOriginalFilename()).thenReturn("test.pdf");
+        when(mockFile.getContentType()).thenReturn("application/pdf");
+    }
+
+    @Test
+    void testStoreFile() throws IOException {
+        // Arrange
+        byte[] fileContent = "Test PDF content".getBytes();
+        when(mockFile.getBytes()).thenReturn(fileContent);
+        
+        // Set up mock to handle transferTo by writing the file
+        doAnswer(invocation -> {
+            java.io.File file = invocation.getArgument(0);
+            Files.write(file.toPath(), fileContent);
+            return null;
+        }).when(mockFile).transferTo(any(java.io.File.class));
+        
+        // Act
+        String fileId = fileStorage.storeFile(mockFile);
+        
+        // Assert
+        assertNotNull(fileId);
+        assertTrue(Files.exists(tempDir.resolve(fileId)));
+        verify(mockFile).transferTo(any(java.io.File.class));
+    }
+    
+    @Test
+    void testStoreBytes() throws IOException {
+        // Arrange
+        byte[] fileContent = "Test PDF content".getBytes();
+        String originalName = "test.pdf";
+        
+        // Act
+        String fileId = fileStorage.storeBytes(fileContent, originalName);
+        
+        // Assert
+        assertNotNull(fileId);
+        assertTrue(Files.exists(tempDir.resolve(fileId)));
+        assertArrayEquals(fileContent, Files.readAllBytes(tempDir.resolve(fileId)));
+    }
+    
+    @Test
+    void testRetrieveFile() throws IOException {
+        // Arrange
+        byte[] fileContent = "Test PDF content".getBytes();
+        String fileId = UUID.randomUUID().toString();
+        Path filePath = tempDir.resolve(fileId);
+        Files.write(filePath, fileContent);
+        
+        MultipartFile expectedFile = mock(MultipartFile.class);
+        when(fileOrUploadService.toMockMultipartFile(eq(fileId), eq(fileContent)))
+            .thenReturn(expectedFile);
+        
+        // Act
+        MultipartFile result = fileStorage.retrieveFile(fileId);
+        
+        // Assert
+        assertSame(expectedFile, result);
+        verify(fileOrUploadService).toMockMultipartFile(eq(fileId), eq(fileContent));
+    }
+    
+    @Test
+    void testRetrieveBytes() throws IOException {
+        // Arrange
+        byte[] fileContent = "Test PDF content".getBytes();
+        String fileId = UUID.randomUUID().toString();
+        Path filePath = tempDir.resolve(fileId);
+        Files.write(filePath, fileContent);
+        
+        // Act
+        byte[] result = fileStorage.retrieveBytes(fileId);
+        
+        // Assert
+        assertArrayEquals(fileContent, result);
+    }
+    
+    @Test
+    void testRetrieveFile_FileNotFound() {
+        // Arrange
+        String nonExistentFileId = "non-existent-file";
+        
+        // Act & Assert
+        assertThrows(IOException.class, () -> fileStorage.retrieveFile(nonExistentFileId));
+    }
+    
+    @Test
+    void testRetrieveBytes_FileNotFound() {
+        // Arrange
+        String nonExistentFileId = "non-existent-file";
+        
+        // Act & Assert
+        assertThrows(IOException.class, () -> fileStorage.retrieveBytes(nonExistentFileId));
+    }
+    
+    @Test
+    void testDeleteFile() throws IOException {
+        // Arrange
+        byte[] fileContent = "Test PDF content".getBytes();
+        String fileId = UUID.randomUUID().toString();
+        Path filePath = tempDir.resolve(fileId);
+        Files.write(filePath, fileContent);
+        
+        // Act
+        boolean result = fileStorage.deleteFile(fileId);
+        
+        // Assert
+        assertTrue(result);
+        assertFalse(Files.exists(filePath));
+    }
+    
+    @Test
+    void testDeleteFile_FileNotFound() {
+        // Arrange
+        String nonExistentFileId = "non-existent-file";
+        
+        // Act
+        boolean result = fileStorage.deleteFile(nonExistentFileId);
+        
+        // Assert
+        assertFalse(result);
+    }
+    
+    @Test
+    void testFileExists() throws IOException {
+        // Arrange
+        byte[] fileContent = "Test PDF content".getBytes();
+        String fileId = UUID.randomUUID().toString();
+        Path filePath = tempDir.resolve(fileId);
+        Files.write(filePath, fileContent);
+        
+        // Act
+        boolean result = fileStorage.fileExists(fileId);
+        
+        // Assert
+        assertTrue(result);
+    }
+    
+    @Test
+    void testFileExists_FileNotFound() {
+        // Arrange
+        String nonExistentFileId = "non-existent-file";
+        
+        // Act
+        boolean result = fileStorage.fileExists(nonExistentFileId);
+        
+        // Assert
+        assertFalse(result);
+    }
+}

common/src/test/java/stirling/software/common/service/TaskManagerTest.java

@@ -0,0 +1,255 @@
+package stirling.software.common.service;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.time.LocalDateTime;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import stirling.software.common.model.job.JobResult;
+import stirling.software.common.model.job.JobStats;
+
+class TaskManagerTest {
+
+    @Mock
+    private FileStorage fileStorage;
+    
+    @InjectMocks
+    private TaskManager taskManager;
+    
+    private AutoCloseable closeable;
+
+    @BeforeEach
+    void setUp() {
+        closeable = MockitoAnnotations.openMocks(this);
+        ReflectionTestUtils.setField(taskManager, "jobResultExpiryMinutes", 30);
+    }
+    
+    @AfterEach
+    void tearDown() throws Exception {
+        closeable.close();
+    }
+
+    @Test
+    void testCreateTask() {
+        // Act
+        String jobId = UUID.randomUUID().toString();
+        taskManager.createTask(jobId);
+        
+        // Assert
+        JobResult result = taskManager.getJobResult(jobId);
+        assertNotNull(result);
+        assertEquals(jobId, result.getJobId());
+        assertFalse(result.isComplete());
+        assertNotNull(result.getCreatedAt());
+    }
+    
+    @Test
+    void testSetResult() {
+        // Arrange
+        String jobId = UUID.randomUUID().toString();
+        taskManager.createTask(jobId);
+        Object resultObject = "Test result";
+        
+        // Act
+        taskManager.setResult(jobId, resultObject);
+        
+        // Assert
+        JobResult result = taskManager.getJobResult(jobId);
+        assertNotNull(result);
+        assertTrue(result.isComplete());
+        assertEquals(resultObject, result.getResult());
+        assertNotNull(result.getCompletedAt());
+    }
+    
+    @Test
+    void testSetFileResult() {
+        // Arrange
+        String jobId = UUID.randomUUID().toString();
+        taskManager.createTask(jobId);
+        String fileId = "file-id";
+        String originalFileName = "test.pdf";
+        String contentType = "application/pdf";
+        
+        // Act
+        taskManager.setFileResult(jobId, fileId, originalFileName, contentType);
+        
+        // Assert
+        JobResult result = taskManager.getJobResult(jobId);
+        assertNotNull(result);
+        assertTrue(result.isComplete());
+        assertEquals(fileId, result.getFileId());
+        assertEquals(originalFileName, result.getOriginalFileName());
+        assertEquals(contentType, result.getContentType());
+        assertNotNull(result.getCompletedAt());
+    }
+    
+    @Test
+    void testSetError() {
+        // Arrange
+        String jobId = UUID.randomUUID().toString();
+        taskManager.createTask(jobId);
+        String errorMessage = "Test error";
+        
+        // Act
+        taskManager.setError(jobId, errorMessage);
+        
+        // Assert
+        JobResult result = taskManager.getJobResult(jobId);
+        assertNotNull(result);
+        assertTrue(result.isComplete());
+        assertEquals(errorMessage, result.getError());
+        assertNotNull(result.getCompletedAt());
+    }
+    
+    @Test
+    void testSetComplete_WithExistingResult() {
+        // Arrange
+        String jobId = UUID.randomUUID().toString();
+        taskManager.createTask(jobId);
+        Object resultObject = "Test result";
+        taskManager.setResult(jobId, resultObject);
+        
+        // Act
+        taskManager.setComplete(jobId);
+        
+        // Assert
+        JobResult result = taskManager.getJobResult(jobId);
+        assertNotNull(result);
+        assertTrue(result.isComplete());
+        assertEquals(resultObject, result.getResult());
+    }
+    
+    @Test
+    void testSetComplete_WithoutExistingResult() {
+        // Arrange
+        String jobId = UUID.randomUUID().toString();
+        taskManager.createTask(jobId);
+        
+        // Act
+        taskManager.setComplete(jobId);
+        
+        // Assert
+        JobResult result = taskManager.getJobResult(jobId);
+        assertNotNull(result);
+        assertTrue(result.isComplete());
+        assertEquals("Task completed successfully", result.getResult());
+    }
+    
+    @Test
+    void testIsComplete() {
+        // Arrange
+        String jobId = UUID.randomUUID().toString();
+        taskManager.createTask(jobId);
+        
+        // Assert - not complete initially
+        assertFalse(taskManager.isComplete(jobId));
+        
+        // Act - mark as complete
+        taskManager.setComplete(jobId);
+        
+        // Assert - now complete
+        assertTrue(taskManager.isComplete(jobId));
+    }
+    
+    @Test
+    void testGetJobStats() {
+        // Arrange
+        // 1. Create active job
+        String activeJobId = "active-job";
+        taskManager.createTask(activeJobId);
+        
+        // 2. Create completed successful job with file
+        String successFileJobId = "success-file-job";
+        taskManager.createTask(successFileJobId);
+        taskManager.setFileResult(successFileJobId, "file-id", "test.pdf", "application/pdf");
+        
+        // 3. Create completed successful job without file
+        String successJobId = "success-job";
+        taskManager.createTask(successJobId);
+        taskManager.setResult(successJobId, "Result");
+        
+        // 4. Create failed job
+        String failedJobId = "failed-job";
+        taskManager.createTask(failedJobId);
+        taskManager.setError(failedJobId, "Error message");
+        
+        // Act
+        JobStats stats = taskManager.getJobStats();
+        
+        // Assert
+        assertEquals(4, stats.getTotalJobs());
+        assertEquals(1, stats.getActiveJobs());
+        assertEquals(3, stats.getCompletedJobs());
+        assertEquals(1, stats.getFailedJobs());
+        assertEquals(2, stats.getSuccessfulJobs());
+        assertEquals(1, stats.getFileResultJobs());
+        assertNotNull(stats.getNewestActiveJobTime());
+        assertNotNull(stats.getOldestActiveJobTime());
+        assertTrue(stats.getAverageProcessingTimeMs() >= 0);
+    }
+    
+    @Test
+    void testCleanupOldJobs() throws Exception {
+        // Arrange
+        // 1. Create a recent completed job
+        String recentJobId = "recent-job";
+        taskManager.createTask(recentJobId);
+        taskManager.setResult(recentJobId, "Result");
+        
+        // 2. Create an old completed job with file result
+        String oldJobId = "old-job";
+        taskManager.createTask(oldJobId);
+        JobResult oldJob = taskManager.getJobResult(oldJobId);
+        
+        // Manually set the completion time to be older than the expiry
+        LocalDateTime oldTime = LocalDateTime.now().minusHours(1);
+        ReflectionTestUtils.setField(oldJob, "completedAt", oldTime);
+        ReflectionTestUtils.setField(oldJob, "complete", true);
+        ReflectionTestUtils.setField(oldJob, "fileId", "file-id");
+        ReflectionTestUtils.setField(oldJob, "originalFileName", "test.pdf");
+        ReflectionTestUtils.setField(oldJob, "contentType", "application/pdf");
+        
+        when(fileStorage.deleteFile("file-id")).thenReturn(true);
+        
+        // Obtain access to the private jobResults map
+        Map<String, JobResult> jobResultsMap = (Map<String, JobResult>) ReflectionTestUtils.getField(taskManager, "jobResults");
+        
+        // 3. Create an active job
+        String activeJobId = "active-job";
+        taskManager.createTask(activeJobId);
+        
+        // Verify all jobs are in the map
+        assertTrue(jobResultsMap.containsKey(recentJobId));
+        assertTrue(jobResultsMap.containsKey(oldJobId));
+        assertTrue(jobResultsMap.containsKey(activeJobId));
+        
+        // Act
+        taskManager.cleanupOldJobs();
+        
+        // Assert - the old job should be removed
+        assertFalse(jobResultsMap.containsKey(oldJobId));
+        assertTrue(jobResultsMap.containsKey(recentJobId));
+        assertTrue(jobResultsMap.containsKey(activeJobId));
+        verify(fileStorage).deleteFile("file-id");
+    }
+    
+    @Test
+    void testShutdown() throws Exception {
+        // This mainly tests that the shutdown method doesn't throw exceptions
+        taskManager.shutdown();
+        
+        // Verify the executor service is shutdown
+        // This is difficult to test directly, but we can verify it doesn't throw exceptions
+    }
+}