Add unit tests for AICC, SCORM, and BaseParser components

Introduce comprehensive unit tests for `AiccDetectorPlugin`, `BaseModuleMetadata`, and `BaseParser` to validate functionality, including edge cases and exception handling. Ensure high coverage for detection logic, metadata extraction, and parser operations.

Author: jcputney

CLAUDE.md

@@ -9,6 +9,10 @@ This is a Java library for parsing and validating eLearning module manifests in
 - AICC (INI-based format)
 - cmi5 (XML-based)
 
+## Code Style Guidelines
+
+- Use imports whenever possible, avoiding fully qualified class references
+
 ## Build Commands
 
 ```bash

pom.xml

@@ -72,6 +72,7 @@
     <version.slf4j>2.0.17</version.slf4j>
     <version.testcontainers>1.21.0</version.testcontainers>
     <version.threeten>1.8.0</version.threeten>
+    <version.mockito>5.17.0</version.mockito>
   </properties>
 
   <dependencyManagement>
@@ -172,6 +173,20 @@
       <scope>test</scope>
     </dependency>
 
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <version>${version.mockito}</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-junit-jupiter</artifactId>
+      <version>${version.mockito}</version>
+      <scope>test</scope>
+    </dependency>
+
     <!-- Testcontainers Dependencies -->
     <dependency>
       <groupId>org.testcontainers</groupId>

src/main/java/dev/jcputney/elearning/parser/impl/DefaultModuleFileProvider.java

@@ -110,8 +110,21 @@ public String getRootPath() {
   @Override
   public boolean hasXapiSupport() {
     log.debug("Checking for xAPI support");
-    boolean xapiJsExists = fileAccess.fileExists(XAPI_JS_FILE);
-    boolean sendStatementExists = fileAccess.fileExists(XAPI_SEND_STATEMENT_FILE);
+    boolean xapiJsExists = false;
+    boolean sendStatementExists = false;
+    
+    try {
+      xapiJsExists = fileAccess.fileExists(XAPI_JS_FILE);
+    } catch (Exception e) {
+      log.debug("Error checking for xAPI JS file: {}", e.getMessage());
+    }
+    
+    try {
+      sendStatementExists = fileAccess.fileExists(XAPI_SEND_STATEMENT_FILE);
+    } catch (Exception e) {
+      log.debug("Error checking for xAPI Statement file: {}", e.getMessage());
+    }
+    
     boolean hasXapi = xapiJsExists || sendStatementExists;
 
     if (hasXapi) {

src/main/java/dev/jcputney/elearning/parser/impl/S3FileAccessV1.java

@@ -25,6 +25,7 @@
 import com.amazonaws.services.s3.model.S3Object;
 import com.amazonaws.services.s3.model.S3ObjectSummary;
 import dev.jcputney.elearning.parser.api.FileAccess;
+import dev.jcputney.elearning.parser.util.LogMarkers;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -39,11 +40,10 @@
 import java.util.stream.Collectors;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
-import dev.jcputney.elearning.parser.util.LogMarkers;
 
 /**
- * Optimized implementation of FileAccess using AWS S3 SDK v1 with batch operations,
- * streaming support, and intelligent caching.
+ * Optimized implementation of FileAccess using AWS S3 SDK v1 with batch operations, streaming
+ * support, and intelligent caching.
  */
 @Slf4j
 @SuppressWarnings("unused")
@@ -59,7 +59,7 @@ public class S3FileAccessV1 implements FileAccess {
   private final AmazonS3 s3Client;
   private final String bucketName;
   private final ExecutorService executorService;
-  
+
   // Caches for performance
   private final Map<String, Boolean> fileExistsCache = new ConcurrentHashMap<>();
   private final Map<String, List<String>> directoryListCache = new ConcurrentHashMap<>();
@@ -88,7 +88,7 @@ public S3FileAccessV1(AmazonS3 s3Client, String bucketName, String rootPath) {
 
     // Lazy initialization of root path detection
     this.rootPath = processedPath;
-    
+
     if (this.rootPath.endsWith("/")) {
       this.rootPath = this.rootPath.substring(0, this.rootPath.length() - 1);
     }
@@ -115,7 +115,7 @@ public Map<String, Boolean> fileExistsBatch(List<String> paths) {
     // Get cached results first
     Map<String, Boolean> results = new ConcurrentHashMap<>();
     List<String> uncachedPaths = new ArrayList<>();
-    
+
     for (String path : paths) {
       Boolean cached = fileExistsCache.get(path);
       if (cached != null) {
@@ -124,17 +124,18 @@ public Map<String, Boolean> fileExistsBatch(List<String> paths) {
         uncachedPaths.add(path);
       }
     }
-    
+
     // Check uncached paths in parallel
     if (!uncachedPaths.isEmpty()) {
-      List<CompletableFuture<Map.Entry<String, Boolean>>> futures = uncachedPaths.stream()
+      List<CompletableFuture<Map.Entry<String, Boolean>>> futures = uncachedPaths
+          .stream()
           .map(path -> CompletableFuture.supplyAsync(() -> {
             boolean exists = checkFileExistsOnS3(path);
             fileExistsCache.put(path, exists);
             return Map.entry(path, exists);
           }, executorService))
           .toList();
-      
+
       futures.forEach(future -> {
         try {
           Map.Entry<String, Boolean> result = future.join();
@@ -144,47 +145,54 @@ public Map<String, Boolean> fileExistsBatch(List<String> paths) {
         }
       });
     }
-    
+
     return results;
   }
 
   /**
    * Prefetch common module files in parallel for faster subsequent access.
    */
   public void prefetchCommonFiles() {
-    List<String> commonFiles = COMMON_MODULE_FILES.stream()
+    List<String> commonFiles = COMMON_MODULE_FILES
+        .stream()
         .filter(file -> !smallFileCache.containsKey(file))
         .toList();
-    
+
     if (commonFiles.isEmpty()) {
       return;
     }
-    
+
     log.debug(LogMarkers.S3_VERBOSE, "Prefetching {} common module files", commonFiles.size());
-    
-    List<CompletableFuture<Void>> futures = commonFiles.stream()
+
+    List<CompletableFuture<Void>> futures = commonFiles
+        .stream()
         .map(file -> CompletableFuture.runAsync(() -> {
           try {
             String fullFilePath = fullPath(file);
             if (checkFileExistsOnS3(file)) {
               // Get file size first
               long size = getFileSizeOnS3(file);
               fileSizeCache.put(file, size);
-              
+
               // Only cache small files
               if (size <= STREAMING_THRESHOLD) {
-                byte[] content = s3Client.getObjectAsString(bucketName, fullFilePath).getBytes();
+                byte[] content = s3Client
+                    .getObjectAsString(bucketName, fullFilePath)
+                    .getBytes();
                 smallFileCache.put(file, content);
-                log.debug(LogMarkers.S3_VERBOSE, "Prefetched file: {} ({} bytes)", file, content.length);
+                log.debug(LogMarkers.S3_VERBOSE, "Prefetched file: {} ({} bytes)", file,
+                    content.length);
               }
             }
           } catch (Exception e) {
             // Failed to prefetch file - this is expected for missing files
           }
         }, executorService))
         .toList();
-    
-    CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
+
+    CompletableFuture
+        .allOf(futures.toArray(new CompletableFuture[0]))
+        .join();
   }
 
   /**
@@ -212,30 +220,33 @@ public InputStream getFileContentsInternal(String path) throws IOException {
       log.debug(LogMarkers.S3_VERBOSE, "Returning cached content for file: {}", path);
       return new ByteArrayInputStream(cachedContent);
     }
-    
+
     // Get file size to determine strategy
     Long cachedSize = fileSizeCache.get(path);
     long fileSize = cachedSize != null ? cachedSize : getFileSizeOnS3(path);
-    
+
     if (cachedSize == null) {
       fileSizeCache.put(path, fileSize);
     }
-    
+
     String fullFilePath = fullPath(path);
-    
+
     if (fileSize <= STREAMING_THRESHOLD) {
       // Cache small files for future use
       log.debug(LogMarkers.S3_VERBOSE, "Caching small file: {} ({} bytes)", path, fileSize);
       String content = s3Client.getObjectAsString(bucketName, fullFilePath);
       byte[] contentBytes = content.getBytes();
-      
+
       // Implement simple cache size management
       if (smallFileCache.size() >= MAX_CACHE_SIZE) {
         // Remove oldest entry (simple FIFO)
-        String oldestKey = smallFileCache.keySet().iterator().next();
+        String oldestKey = smallFileCache
+            .keySet()
+            .iterator()
+            .next();
         smallFileCache.remove(oldestKey);
       }
-      
+
       smallFileCache.put(path, contentBytes);
       return new ByteArrayInputStream(contentBytes);
     } else {
@@ -274,7 +285,10 @@ public void clearCaches() {
   }
 
   /**
-   * Get cache statistics for monitoring.
+   * Retrieves statistics about various internal caches used in the class.
+   *
+   * @return A map where the keys are the cache names (e.g., "fileExistsCache",
+   * "directoryListCache", etc.) and the values are the respective sizes of these caches.
    */
   public Map<String, Integer> getCacheStats() {
     return Map.of(
@@ -305,7 +319,9 @@ private boolean checkFileExistsOnS3(String path) {
 
   private long getFileSizeOnS3(String path) {
     try {
-      return s3Client.getObjectMetadata(bucketName, fullPath(path)).getContentLength();
+      return s3Client
+          .getObjectMetadata(bucketName, fullPath(path))
+          .getContentLength();
     } catch (AmazonServiceException e) {
       log.debug("Failed to get file size for path: {}", path, e);
       return 0;
@@ -316,22 +332,25 @@ private List<String> listFilesOnS3(String directoryPath) {
     try {
       List<String> allKeys = new ArrayList<>();
       String prefix = fullPath(directoryPath);
-      
+
       ListObjectsRequest request = new ListObjectsRequest()
           .withBucketName(bucketName)
           .withPrefix(prefix)
           .withMaxKeys(1000);
-      
+
       ObjectListing listing;
       do {
         listing = s3Client.listObjects(request);
-        allKeys.addAll(listing.getObjectSummaries().stream()
+        allKeys.addAll(listing
+            .getObjectSummaries()
+            .stream()
             .map(S3ObjectSummary::getKey)
             .collect(Collectors.toList()));
         request.setMarker(listing.getNextMarker());
       } while (listing.isTruncated());
-      
-      log.debug(LogMarkers.S3_VERBOSE, "Listed {} files in directory: {}", allKeys.size(), directoryPath);
+
+      log.debug(LogMarkers.S3_VERBOSE, "Listed {} files in directory: {}", allKeys.size(),
+          directoryPath);
       return allKeys;
     } catch (AmazonServiceException e) {
       log.debug("Failed to list files in directory: {}", directoryPath, e);