feat: rust analysis support tests

Author: soul2zimate

src/test/java/io/github/guacsec/trustifyda/providers/RustProviderPerformanceTest.java

@@ -0,0 +1,276 @@
+/*
+ * Copyright 2023-2025 Trustify Dependency Analytics Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.github.guacsec.trustifyda.providers;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+public class RustProviderPerformanceTest {
+
+  @Test
+  public void testLargeCargoTomlPerformanceBenchmark(@TempDir Path tempDir) throws Exception {
+    System.out.println("=== RustProvider Performance Benchmark ===");
+
+    // Create multiple large Cargo.toml files to test performance
+    List<Path> testFiles = createPerformanceTestFiles(tempDir);
+
+    for (int fileIndex = 0; fileIndex < testFiles.size(); fileIndex++) {
+      Path cargoToml = testFiles.get(fileIndex);
+      System.out.println(
+          "\nTesting file " + (fileIndex + 1) + " with complexity level " + (fileIndex + 1));
+
+      // Warm up JVM for more accurate measurements
+      for (int warmup = 0; warmup < 3; warmup++) {
+        RustProvider provider = new RustProvider(cargoToml);
+        provider.provideComponent();
+      }
+
+      // Measure performance over multiple runs
+      List<Long> durations = new ArrayList<>();
+      for (int run = 0; run < 10; run++) {
+        long startTime = System.nanoTime();
+
+        RustProvider provider = new RustProvider(cargoToml);
+        var result = provider.provideComponent();
+
+        long endTime = System.nanoTime();
+        long duration = (endTime - startTime) / 1_000_000; // Convert to milliseconds
+
+        durations.add(duration);
+        assertNotNull(result);
+        assertTrue(result.buffer.length > 0);
+      }
+
+      // Calculate statistics
+      long avgDuration = durations.stream().mapToLong(Long::longValue).sum() / durations.size();
+      long minDuration = durations.stream().mapToLong(Long::longValue).min().orElse(0);
+      long maxDuration = durations.stream().mapToLong(Long::longValue).max().orElse(0);
+
+      System.out.println("Performance Results:");
+      System.out.println("  Average: " + avgDuration + "ms");
+      System.out.println("  Min:     " + minDuration + "ms");
+      System.out.println("  Max:     " + maxDuration + "ms");
+
+      // Performance assertions
+      assertTrue(
+          avgDuration < 200, "Average parsing should be under 200ms, got " + avgDuration + "ms");
+      assertTrue(maxDuration < 500, "Max parsing should be under 500ms, got " + maxDuration + "ms");
+    }
+
+    System.out.println("\n✓ Performance benchmark completed successfully!");
+  }
+
+  @Test
+  public void testCachePerformance(@TempDir Path tempDir) throws Exception {
+    System.out.println("\n=== Cache Performance Test ===");
+
+    // Create a moderately complex Cargo.toml
+    Path cargoToml = tempDir.resolve("Cargo.toml");
+    String content =
+        """
+        [package]
+        name = "cache-test-project"
+        version = "1.0.0"
+        edition = "2021"
+
+        [dependencies]
+        serde = "1.0"
+        tokio = { version = "1.0", features = ["full"] }
+        anyhow = "1.0"
+        clap = "4.0"
+        reqwest = { version = "0.11", features = ["json"] }
+        """;
+    Files.writeString(cargoToml, content);
+
+    // First call (cache miss)
+    long startTime1 = System.nanoTime();
+    RustProvider provider1 = new RustProvider(cargoToml);
+    var result1 = provider1.provideComponent();
+    long duration1 = (System.nanoTime() - startTime1) / 1_000_000;
+
+    // Second call (should hit cache if cargo tree was executed)
+    long startTime2 = System.nanoTime();
+    RustProvider provider2 = new RustProvider(cargoToml);
+    var result2 = provider2.provideComponent();
+    long duration2 = (System.nanoTime() - startTime2) / 1_000_000;
+
+    // Third call (should also hit cache)
+    long startTime3 = System.nanoTime();
+    RustProvider provider3 = new RustProvider(cargoToml);
+    var result3 = provider3.provideComponent();
+    long duration3 = (System.nanoTime() - startTime3) / 1_000_000;
+
+    System.out.println("Cache Performance Results:");
+    System.out.println("  First call (cache miss):  " + duration1 + "ms");
+    System.out.println("  Second call (cache hit):  " + duration2 + "ms");
+    System.out.println("  Third call (cache hit):   " + duration3 + "ms");
+
+    // Verify cache effectiveness (second and third calls should be faster or similar)
+    // Note: If cargo is not available, all calls should be fast and similar
+    assertTrue(duration2 <= duration1 + 10, "Second call should not be significantly slower");
+    assertTrue(duration3 <= duration1 + 10, "Third call should not be significantly slower");
+
+    // Verify results are consistent
+    assertNotNull(result1);
+    assertNotNull(result2);
+    assertNotNull(result3);
+    assertEquals(result1.buffer.length, result2.buffer.length);
+    assertEquals(result1.buffer.length, result3.buffer.length);
+
+    System.out.println("✓ Cache performance test passed!");
+  }
+
+  @Test
+  public void testMemoryUsage(@TempDir Path tempDir) throws Exception {
+    System.out.println("\n=== Memory Usage Test ===");
+
+    // Create a large Cargo.toml file
+    Path cargoToml = createLargeCargoToml(tempDir, 500); // 500 dependencies
+
+    // Measure memory usage
+    Runtime runtime = Runtime.getRuntime();
+
+    // Force GC before test
+    System.gc();
+    Thread.sleep(100);
+    long memoryBefore = runtime.totalMemory() - runtime.freeMemory();
+
+    // Process the large file
+    RustProvider provider = new RustProvider(cargoToml);
+    var result = provider.provideComponent();
+
+    long memoryAfter = runtime.totalMemory() - runtime.freeMemory();
+    long memoryUsed = memoryAfter - memoryBefore;
+
+    System.out.println("Memory Usage Results:");
+    System.out.println("  Memory before: " + (memoryBefore / 1024 / 1024) + " MB");
+    System.out.println("  Memory after:  " + (memoryAfter / 1024 / 1024) + " MB");
+    System.out.println("  Memory used:   " + (memoryUsed / 1024 / 1024) + " MB");
+
+    // Memory usage should be reasonable (less than 100MB for a large project)
+    assertTrue(
+        memoryUsed < 100 * 1024 * 1024,
+        "Memory usage should be under 100MB, got " + (memoryUsed / 1024 / 1024) + " MB");
+
+    // Verify the result is valid
+    assertNotNull(result);
+    assertTrue(result.buffer.length > 0);
+
+    String sbomContent = new String(result.buffer);
+    assertTrue(sbomContent.contains("large-memory-test"));
+
+    System.out.println("✓ Memory usage test passed!");
+  }
+
+  private List<Path> createPerformanceTestFiles(Path tempDir) throws Exception {
+    List<Path> files = new ArrayList<>();
+
+    // Test file 1: Small project
+    files.add(createSmallCargoToml(tempDir));
+
+    // Test file 2: Medium project
+    files.add(createMediumCargoToml(tempDir));
+
+    // Test file 3: Large project
+    files.add(createLargeCargoToml(tempDir, 200));
+
+    return files;
+  }
+
+  private Path createSmallCargoToml(Path tempDir) throws Exception {
+    Path cargoToml = tempDir.resolve("small-Cargo.toml");
+    String content =
+        """
+        [package]
+        name = "small-test-project"
+        version = "1.0.0"
+        edition = "2021"
+
+        [dependencies]
+        serde = "1.0"
+        anyhow = "1.0"
+        """;
+    Files.writeString(cargoToml, content);
+    return cargoToml;
+  }
+
+  private Path createMediumCargoToml(Path tempDir) throws Exception {
+    Path cargoToml = tempDir.resolve("medium-Cargo.toml");
+    StringBuilder contentBuilder = new StringBuilder();
+    contentBuilder.append(
+        """
+        [package]
+        name = "medium-test-project"
+        version = "2.0.0"
+        edition = "2021"
+
+        [dependencies]
+        """);
+
+    // Add 50 dependencies
+    for (int i = 1; i <= 50; i++) {
+      contentBuilder.append(String.format("dep%d = \"1.0\"%n", i));
+    }
+
+    Files.writeString(cargoToml, contentBuilder.toString());
+    return cargoToml;
+  }
+
+  private Path createLargeCargoToml(Path tempDir, int numDeps) throws Exception {
+    Path cargoToml = tempDir.resolve("large-Cargo.toml");
+    StringBuilder contentBuilder = new StringBuilder();
+    contentBuilder.append(
+        """
+        [package]
+        name = "large-memory-test"
+        version = "3.0.0"
+        edition = "2021"
+
+        [dependencies]
+        """);
+
+    // Add specified number of dependencies
+    for (int i = 1; i <= numDeps; i++) {
+      if (i % 10 == 0) {
+        // Add some with ignore patterns
+        contentBuilder.append(String.format("large-dep%d = \"1.0\" # trustify-da-ignore%n", i));
+      } else {
+        contentBuilder.append(String.format("large-dep%d = \"1.0\"%n", i));
+      }
+    }
+
+    contentBuilder.append(
+        """
+
+[build-dependencies]
+""");
+
+    // Add build dependencies
+    for (int i = 1; i <= numDeps / 4; i++) {
+      contentBuilder.append(String.format("build-dep%d = \"1.0\"%n", i));
+    }
+
+    Files.writeString(cargoToml, contentBuilder.toString());
+    return cargoToml;
+  }
+}