Add test

Signed-off-by: Bernát Gábor <gaborjbernat@gmail.com>

Author: gaborbernat

opengrok-indexer/src/test/java/org/opengrok/indexer/search/SearchEngineTest.java

@@ -24,7 +24,10 @@
 package org.opengrok.indexer.search;
 
 import java.io.File;
+import java.io.FileOutputStream;
+import java.util.ArrayList;
 import java.util.Collections;
+import java.util.List;
 import java.util.TreeSet;
 
 import org.junit.jupiter.api.AfterAll;
@@ -36,7 +39,9 @@
 import org.opengrok.indexer.util.TestRepository;
 
 import org.opengrok.indexer.history.RepositoryFactory;
+import org.opengrok.indexer.web.SortOrder;
 
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
@@ -148,6 +153,103 @@ void testGetQuery() throws Exception {
                 instance.getQuery());
     }
 
+    @Test
+    void testSortOrderByRelevancy() {
+        SearchEngine instance = new SearchEngine();
+        instance.setFile("main.c OR header.h");
+        instance.setFreetext("arguments OR stdio");
+        instance.setSortOrder(SortOrder.RELEVANCY);
+        int hitsCount = instance.search();
+        List<Hit> hits = new ArrayList<>();
+        instance.results(0, hitsCount, hits);
+        assertTrue(hits.size() > 1, "Should return at least 2 hits for RELEVANCY sort to check order");
+
+        List<String> results = new ArrayList<>();
+        for (Hit hit : hits) {
+            results.add(hit.getPath() + "@" + hit.getLineno());
+        }
+        final String[] expectedResults = {
+            "/mercurial/header.h@2",
+            "/bazaar/header.h@2",
+            "/teamware/header.h@2",
+            "/git/header.h@2",
+            "/rcs_test/header.h@2",
+            "/bazaar/main.c@5",
+            "/rcs_test/main.c@5",
+            "/teamware/main.c@5",
+            "/mercurial/main.c@5",
+            "/git/main.c@5",
+            "/cvs_test/cvsrepo/main.c@7"
+        };
+
+        assertArrayEquals(expectedResults, results.toArray());
+
+        instance.destroy();
+    }
+
+    @Test
+    void testSortOrderLastModified() {
+        SearchEngine instance = new SearchEngine();
+        instance.setFile("main.c");
+        instance.setFreetext("arguments");
+        instance.setSortOrder(SortOrder.LASTMODIFIED);
+        int hitsCount = instance.search();
+        List<Hit> hits = new ArrayList<>();
+        instance.results(0, hitsCount, hits);
+        assertTrue(hits.size() > 1, "Should return at least 2 hits for RELEVANCY sort to check order");
+
+        List<String> results = new ArrayList<>();
+        for (Hit hit : hits) {
+            results.add(hit.getPath() + "@" + hit.getLineno());
+        }
+        final String[] expectedResults = {
+                "/teamware/main.c@5",
+                "/rcs_test/main.c@5",
+                "/mercurial/main.c@5",
+                "/git/main.c@5",
+                "/cvs_test/cvsrepo/main.c@7",
+                "/bazaar/main.c@5"
+        };
+
+        assertArrayEquals(expectedResults, results.toArray());
+
+        instance.destroy();
+    }
+
+    @Test
+    void testSortOrderByPath() {
+        SearchEngine instance = new SearchEngine();
+        instance.setFile("main.c OR header.h");
+        instance.setFreetext("arguments OR stdio");
+        instance.setSortOrder(SortOrder.BY_PATH);
+        int hitsCount = instance.search();
+        List<Hit> hits = new ArrayList<>();
+        instance.results(0, hitsCount, hits);
+        assertTrue(hits.size() > 1, "Should return at least 2 hits for RELEVANCY sort to check order");
+
+        List<String> results = new ArrayList<>();
+        for (Hit hit : hits) {
+            results.add(hit.getPath() + "@" + hit.getLineno());
+        }
+        final String[] expectedResults = {
+            "/bazaar/header.h@2",
+            "/bazaar/main.c@5",
+            "/cvs_test/cvsrepo/main.c@7",
+            "/git/header.h@2",
+            "/git/main.c@5",
+            "/mercurial/header.h@2",
+            "/mercurial/main.c@5",
+            "/rcs_test/header.h@2",
+            "/rcs_test/main.c@5",
+            "/teamware/header.h@2",
+            "/teamware/main.c@5"
+        };
+
+        assertArrayEquals(expectedResults, results.toArray());
+
+        instance.destroy();
+    }
+
     /* see https://github.com/oracle/opengrok/issues/2030
     @Test
     void testSearch() {

opengrok-indexer/src/test/java/org/opengrok/indexer/util/TestRepository.java

@@ -33,6 +33,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.stream.Stream;
 
@@ -111,25 +112,43 @@ public void create(@NotNull final URL url) throws IOException, URISyntaxExceptio
      * @throws IOException on error
      */
     public void copyDirectory(Path src, Path dest) throws IOException {
+        // Create a deterministic order of paths for both sorting by creation time, path and relevancy
+        List<Path> allPaths;
         try (Stream<Path> stream = Files.walk(src)) {
-            stream.forEach(sourceFile -> {
-                if (sourceFile.equals(src)) {
-                    return;
+            allPaths = stream.filter(p -> !p.equals(src)).sorted().toList();
+        }
+        // Set base time to now, and go back in time for each subsequent path
+        java.time.Instant baseTime = java.time.Instant.now();
+        for (int i = 0; i < allPaths.size(); i++) {
+            Path sourcePath = allPaths.get(i);
+            Path destRelativePath = getDestinationRelativePath(src, sourcePath);
+            Path destPath = dest.resolve(destRelativePath);
+            var fileTime = java.nio.file.attribute.FileTime.from(baseTime.plusSeconds(i * 60L));
+            if (Files.isDirectory(sourcePath)) {
+                // Create directory and set timestamps
+                if (!Files.exists(destPath)) {
+                    Files.createDirectories(destPath);
                 }
                 try {
-                    Path destRelativePath = getDestinationRelativePath(src, sourceFile);
-                    Path destPath = dest.resolve(destRelativePath);
-                    if (Files.isDirectory(sourceFile)) {
-                        if (!Files.exists(destPath)) {
-                            Files.createDirectory(destPath);
-                        }
-                        return;
-                    }
-                    Files.copy(sourceFile, destPath, REPLACE_EXISTING, COPY_ATTRIBUTES);
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
+                    Files.setLastModifiedTime(destPath, fileTime);
+                    Files.setAttribute(destPath, "basic:creationTime", fileTime);
+                } catch (Exception ignored) {
+                    // Not all filesystems support creationTime
+                }
+            } else {
+                // Ensure parent directory exists before copying file
+                Path parentDir = destPath.getParent();
+                if (parentDir != null && !Files.exists(parentDir)) {
+                    Files.createDirectories(parentDir);
                 }
-            });
+                Files.copy(sourcePath, destPath, REPLACE_EXISTING, COPY_ATTRIBUTES);
+                Files.setLastModifiedTime(destPath, fileTime);
+                try {
+                    Files.setAttribute(destPath, "basic:creationTime", fileTime);
+                } catch (Exception ignored) {
+                    // Not all filesystems support creationTime
+                }
+            }
         }
     }