chore(SP-2487): add test case to verify correct obfuscation

Author: isasmendiagus

src/test/java/com/scanoss/TestScanner.java

@@ -22,29 +22,61 @@
  */
 package com.scanoss;
 
+import com.google.gson.Gson;
+import com.scanoss.dto.ScanFileDetails;
+import com.scanoss.dto.ScanFileResult;
+import com.scanoss.dto.ServerDetails;
+import com.scanoss.dto.enums.MatchType;
 import com.scanoss.exceptions.ScannerException;
 import com.scanoss.filters.FilterConfig;
 import com.scanoss.settings.ScanossSettings;
 import com.scanoss.utils.JsonUtils;
+import com.scanoss.utils.WinnowingUtils;
 import lombok.extern.slf4j.Slf4j;
+import okhttp3.mockwebserver.Dispatcher;
+import okhttp3.mockwebserver.MockResponse;
+import okhttp3.mockwebserver.MockWebServer;
+import okhttp3.mockwebserver.RecordedRequest;
+import org.jetbrains.annotations.NotNull;
+import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
+import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
+import java.nio.file.*;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.stream.Collectors;
 
 import static org.junit.Assert.*;
 
 @Slf4j
 public class TestScanner {
+    private MockWebServer server;
+
+
     @Before
-    public void Setup() {
+    public void Setup() throws IOException{
         log.info("Starting Scanner test cases...");
         log.debug("Logging debug enabled");
         log.trace("Logging trace enabled");
+        log.info("Starting Mock Server...");
+        server = new MockWebServer();
+        server.start();
+    }
+
+    @After
+    public void Finish() {
+        log.info("Shutting down mock server.");
+        try {
+            server.close();
+            server.shutdown();
+        } catch (IOException e) {
+            log.warn("Some issue shutting down mock server: {}", e.getLocalizedMessage());
+        }
     }
 
     @Test
@@ -409,4 +441,116 @@ public void TestScannerCustomFilterConfig() {
 
         log.info("Finished {} -->", methodName);
     }
-}
+
+    /**
+     * Test that we can scan a folder with obfuscation enabled using a mock server.
+     * This test focuses on the path obfuscation/deobfuscation functionality in a multi-threaded environment.
+     * The dispatcher supports handling multiple files in a single request.
+     */
+    @Test
+    public void testConcurrentScanWithObfuscation() throws IOException {
+        final String folderToScan = "src/test";
+
+        // Set to capture all paths received by the server
+        final Set<String> receivedPaths = ConcurrentHashMap.newKeySet();
+
+        // Collect all files in the src/test folder before scanning
+        final Set<String> allSourceFilePaths = Files.walk(Paths.get(folderToScan))
+                .filter(path -> !Files.isDirectory(path))
+                .map(path -> {
+                    // Convert to relative path with forward slashes
+                    String relativePath = Paths.get(folderToScan).relativize(path).toString();
+                    return relativePath.replace(File.separatorChar, '/');
+                })
+                .collect(Collectors.toSet());
+
+        log.info("Found {} files in source directory", allSourceFilePaths.size());
+
+
+
+
+
+        // Configure the MockWebServer to return a 'no match' response for any request.
+        // This is important for testing without depending on actual scan results.
+        //TODO: Extend the mock webserver to other tests.
+        final Dispatcher dispatcher = new Dispatcher() {
+            @NotNull
+            @Override
+            public MockResponse dispatch(RecordedRequest request) {
+                // Extract the WFP from the request and parse all obfuscated paths
+                String requestBody = request.getBody().readUtf8();
+                Set<String> paths = WinnowingUtils.extractFilePathsFromWFPBlock(requestBody);
+
+                // Store all received paths for later verification
+                receivedPaths.addAll(paths);
+
+
+                for (String path : paths) {
+                    log.debug("Server received obfuscated path: {}", path);
+                }
+
+                if (paths.isEmpty()) {
+                    return new MockResponse()
+                            .setResponseCode(400)
+                            .setBody("error: Bad Request - No valid obfuscated paths found");
+                }
+
+                // Create response objects using the DTO classes
+                Map<String, List<ScanFileDetails>> responseMap = new HashMap<>();
+
+                // Create server details object (same for all responses)
+                ServerDetails.KbVersion kbVersion = new ServerDetails.KbVersion("25.05", "21.05.21");
+                ServerDetails serverDetails = new ServerDetails("5.4.10", kbVersion);
+
+                // Create a "none" match result for each path
+                for (String path : paths) {
+                    ScanFileDetails noMatchResult = ScanFileDetails.builder()
+                            .matchType(MatchType.none)
+                            .serverDetails(serverDetails)
+                            .build();
+
+                    responseMap.put(path, Collections.singletonList(noMatchResult));
+                }
+
+                // Convert to JSON
+                Gson gson = new Gson();
+                String responseJson = gson.toJson(responseMap);
+
+                return new MockResponse()
+                        .setResponseCode(200)
+                        .setBody(responseJson);
+            }
+        };
+        server.setDispatcher(dispatcher);
+
+        // Create a scanner with obfuscation enabled and multiple threads
+        Scanner scanner = Scanner.builder()
+                .obfuscate(true)
+                .numThreads(8) // Use multiple threads to process files
+                .url(server.url("/api/scan/direct").toString()) // Use our mock server
+                .build();
+
+        // Scan the files to test the full obfuscation/deobfuscation cycle
+        List<String> results = scanner.scanFolder(folderToScan);
+
+
+        // Verify we got scan results
+        assertNotNull("Should have scan results", results);
+        assertFalse("Should have result non empty", results.isEmpty());
+        log.info("Received {} scan results", results.size());
+
+        // Verify paths received by the server are obfuscated (not matching any source file paths)
+        for (String receivedPath : receivedPaths) {
+            assertFalse("Path should be obfuscated and not match any source path: " + receivedPath,
+                    allSourceFilePaths.contains(receivedPath));
+        }
+
+        List<ScanFileResult> resultsDto = JsonUtils.toScanFileResults(results);
+        // Verify (deobfuscation) that all results from scanFolder are valid file paths from our source directory
+        for (ScanFileResult r : resultsDto) {
+            assertTrue("Result should be a valid source file path: " + r.getFilePath(),
+                    allSourceFilePaths.contains(r.getFilePath()));
+        }
+
+    }
+}