git.stella-ops.org/src/Scanner/__Tests/StellaOps.Scanner.Analyzers.Lang.Tests/Rust/RustHeuristicCoverageComparisonTests.cs

using System.Linq;
using System.Text.Json;
using StellaOps.Scanner.Analyzers.Lang.Rust;
using StellaOps.Scanner.Analyzers.Lang.Tests.Harness;
using StellaOps.Scanner.Analyzers.Lang.Tests.TestUtilities;

namespace StellaOps.Scanner.Analyzers.Lang.Tests.Rust;

public sealed class RustHeuristicCoverageComparisonTests
{
    [Fact]
    public async Task HeuristicCoverageExceedsCompetitorBaselineAsync()
    {
        var cancellationToken = TestContext.Current.CancellationToken;
        var fixturePath = TestPaths.ResolveFixture("lang", "rust", "heuristics");
        var baselinePath = Path.Combine(fixturePath, "competitor-baseline.json");
        RustFixtureBinaries.EnsureHeuristicBinary(fixturePath);

        var analyzers = new ILanguageAnalyzer[]
        {
            new RustLanguageAnalyzer()
        };

        var output = await LanguageAnalyzerTestHarness.RunToJsonAsync(
            fixturePath,
            analyzers,
            cancellationToken);

        using var ours = JsonDocument.Parse(output);
        var heuristicNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        foreach (var element in ours.RootElement.EnumerateArray())
        {
            if (!element.TryGetProperty("metadata", out var metadata) || metadata.ValueKind != JsonValueKind.Object)
            {
                continue;
            }

            var provenance = metadata.EnumerateObject()
                .FirstOrDefault(p => string.Equals(p.Name, "provenance", StringComparison.OrdinalIgnoreCase));

            if (provenance.Value.ValueKind == JsonValueKind.String &&
                string.Equals(provenance.Value.GetString(), "heuristic", StringComparison.OrdinalIgnoreCase))
            {
                if (element.TryGetProperty("name", out var nameProperty) && nameProperty.ValueKind == JsonValueKind.String)
                {
                    var value = nameProperty.GetString();
                    if (!string.IsNullOrWhiteSpace(value))
                    {
                        heuristicNames.Add(value);
                    }
                }
            }
        }

        using var competitor = JsonDocument.Parse(await File.ReadAllTextAsync(baselinePath, cancellationToken));
        var competitorNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        if (competitor.RootElement.TryGetProperty("detectedCrates", out var detectedCrates) && detectedCrates.ValueKind == JsonValueKind.Array)
        {
            foreach (var entry in detectedCrates.EnumerateArray())
            {
                if (entry.ValueKind == JsonValueKind.Object && entry.TryGetProperty("name", out var nameProperty) && nameProperty.ValueKind == JsonValueKind.String)
                {
                    var name = nameProperty.GetString();
                    if (!string.IsNullOrWhiteSpace(name))
                    {
                        competitorNames.Add(name);
                    }
                }
            }
        }

        Assert.NotEmpty(competitorNames);
        Assert.True(heuristicNames.IsSupersetOf(competitorNames));

        var improvement = (double)heuristicNames.Count / competitorNames.Count;
        Assert.True(improvement >= 1.15, $"Expected at least 15% improvement; got {improvement:P2} ({heuristicNames.Count} vs {competitorNames.Count}).");
    }
}