save progress

src/Scanner/__Tests/StellaOps.Scanner.Reachability.Tests/GateDetectionTests.cs

@@ -0,0 +1,230 @@
+using StellaOps.Scanner.Reachability.Gates;
+using Xunit;
+
+namespace StellaOps.Scanner.Reachability.Tests;
+
+/// <summary>
+/// Unit tests for gate detection and multiplier calculation.
+/// SPRINT_3405_0001_0001 - Tasks #13, #14, #15
+/// </summary>
+public sealed class GateDetectionTests
+{
+    [Fact]
+    public void GateDetectionResult_Empty_HasNoGates()
+    {
+        Assert.False(GateDetectionResult.Empty.HasGates);
+        Assert.Empty(GateDetectionResult.Empty.Gates);
+        Assert.Null(GateDetectionResult.Empty.PrimaryGate);
+    }
+
+    [Fact]
+    public void GateDetectionResult_WithGates_HasPrimaryGate()
+    {
+        var gates = new[]
+        {
+            CreateGate(GateType.AuthRequired, 0.7),
+            CreateGate(GateType.FeatureFlag, 0.9),
+        };
+
+        var result = new GateDetectionResult { Gates = gates };
+
+        Assert.True(result.HasGates);
+        Assert.Equal(2, result.Gates.Count);
+        Assert.Equal(GateType.FeatureFlag, result.PrimaryGate?.Type);
+    }
+
+    [Fact]
+    public void GateMultiplierConfig_Default_HasExpectedValues()
+    {
+        var config = GateMultiplierConfig.Default;
+
+        Assert.Equal(3000, config.AuthRequiredMultiplierBps);
+        Assert.Equal(2000, config.FeatureFlagMultiplierBps);
+        Assert.Equal(1500, config.AdminOnlyMultiplierBps);
+        Assert.Equal(5000, config.NonDefaultConfigMultiplierBps);
+        Assert.Equal(500, config.MinimumMultiplierBps);
+    }
+
+    [Fact]
+    public async Task CompositeGateDetector_NoDetectors_ReturnsEmpty()
+    {
+        var detector = new CompositeGateDetector([]);
+        var context = CreateContext(["main", "vulnerable_function"]);
+
+        var result = await detector.DetectAllAsync(context);
+
+        Assert.False(result.HasGates);
+        Assert.Equal(10000, result.CombinedMultiplierBps);
+    }
+
+    [Fact]
+    public async Task CompositeGateDetector_EmptyCallPath_ReturnsEmpty()
+    {
+        var detector = new CompositeGateDetector([new MockAuthDetector()]);
+        var context = CreateContext([]);
+
+        var result = await detector.DetectAllAsync(context);
+
+        Assert.False(result.HasGates);
+    }
+
+    [Fact]
+    public async Task CompositeGateDetector_SingleGate_AppliesMultiplier()
+    {
+        var authDetector = new MockAuthDetector(
+            CreateGate(GateType.AuthRequired, 0.95));
+        var detector = new CompositeGateDetector([authDetector]);
+        var context = CreateContext(["main", "auth_check", "vulnerable"]);
+
+        var result = await detector.DetectAllAsync(context);
+
+        Assert.True(result.HasGates);
+        Assert.Single(result.Gates);
+        Assert.Equal(3000, result.CombinedMultiplierBps);
+    }
+
+    [Fact]
+    public async Task CompositeGateDetector_MultipleGateTypes_MultipliesMultipliers()
+    {
+        var authDetector = new MockAuthDetector(
+            CreateGate(GateType.AuthRequired, 0.9));
+        var featureDetector = new MockFeatureFlagDetector(
+            CreateGate(GateType.FeatureFlag, 0.8));
+
+        var detector = new CompositeGateDetector([authDetector, featureDetector]);
+        var context = CreateContext(["main", "auth_check", "feature_check", "vulnerable"]);
+
+        var result = await detector.DetectAllAsync(context);
+
+        Assert.True(result.HasGates);
+        Assert.Equal(2, result.Gates.Count);
+        Assert.Equal(600, result.CombinedMultiplierBps);
+    }
+
+    [Fact]
+    public async Task CompositeGateDetector_DuplicateGates_Deduplicates()
+    {
+        var authDetector1 = new MockAuthDetector(
+            CreateGate(GateType.AuthRequired, 0.9, "checkAuth"));
+        var authDetector2 = new MockAuthDetector(
+            CreateGate(GateType.AuthRequired, 0.7, "checkAuth"));
+
+        var detector = new CompositeGateDetector([authDetector1, authDetector2]);
+        var context = CreateContext(["main", "checkAuth", "vulnerable"]);
+
+        var result = await detector.DetectAllAsync(context);
+
+        Assert.Single(result.Gates);
+        Assert.Equal(0.9, result.Gates[0].Confidence);
+    }
+
+    [Fact]
+    public async Task CompositeGateDetector_AllGateTypes_AppliesMinimumFloor()
+    {
+        var detectors = new IGateDetector[]
+        {
+            new MockAuthDetector(CreateGate(GateType.AuthRequired, 0.9)),
+            new MockFeatureFlagDetector(CreateGate(GateType.FeatureFlag, 0.9)),
+            new MockAdminDetector(CreateGate(GateType.AdminOnly, 0.9)),
+            new MockConfigDetector(CreateGate(GateType.NonDefaultConfig, 0.9)),
+        };
+
+        var detector = new CompositeGateDetector(detectors);
+        var context = CreateContext(["main", "auth", "feature", "admin", "config", "vulnerable"]);
+
+        var result = await detector.DetectAllAsync(context);
+
+        Assert.Equal(4, result.Gates.Count);
+        Assert.Equal(500, result.CombinedMultiplierBps);
+    }
+
+    [Fact]
+    public async Task CompositeGateDetector_DetectorException_ContinuesWithOthers()
+    {
+        var failingDetector = new FailingGateDetector();
+        var authDetector = new MockAuthDetector(
+            CreateGate(GateType.AuthRequired, 0.9));
+
+        var detector = new CompositeGateDetector([failingDetector, authDetector]);
+        var context = CreateContext(["main", "vulnerable"]);
+
+        var result = await detector.DetectAllAsync(context);
+
+        Assert.Single(result.Gates);
+        Assert.Equal(GateType.AuthRequired, result.Gates[0].Type);
+    }
+
+    private static DetectedGate CreateGate(GateType type, double confidence, string symbol = "guard_symbol")
+    {
+        return new DetectedGate
+        {
+            Type = type,
+            Detail = $"{type} gate detected",
+            GuardSymbol = symbol,
+            Confidence = confidence,
+            DetectionMethod = "mock",
+        };
+    }
+
+    private static CallPathContext CreateContext(string[] callPath)
+    {
+        return new CallPathContext
+        {
+            CallPath = callPath,
+            Language = "csharp",
+        };
+    }
+
+    private sealed class MockAuthDetector : IGateDetector
+    {
+        private readonly DetectedGate[] _gates;
+        public GateType GateType => GateType.AuthRequired;
+
+        public MockAuthDetector(params DetectedGate[] gates) => _gates = gates;
+
+        public Task<IReadOnlyList<DetectedGate>> DetectAsync(CallPathContext context, CancellationToken ct)
+            => Task.FromResult<IReadOnlyList<DetectedGate>>(_gates);
+    }
+
+    private sealed class MockFeatureFlagDetector : IGateDetector
+    {
+        private readonly DetectedGate[] _gates;
+        public GateType GateType => GateType.FeatureFlag;
+
+        public MockFeatureFlagDetector(params DetectedGate[] gates) => _gates = gates;
+
+        public Task<IReadOnlyList<DetectedGate>> DetectAsync(CallPathContext context, CancellationToken ct)
+            => Task.FromResult<IReadOnlyList<DetectedGate>>(_gates);
+    }
+
+    private sealed class MockAdminDetector : IGateDetector
+    {
+        private readonly DetectedGate[] _gates;
+        public GateType GateType => GateType.AdminOnly;
+
+        public MockAdminDetector(params DetectedGate[] gates) => _gates = gates;
+
+        public Task<IReadOnlyList<DetectedGate>> DetectAsync(CallPathContext context, CancellationToken ct)
+            => Task.FromResult<IReadOnlyList<DetectedGate>>(_gates);
+    }
+
+    private sealed class MockConfigDetector : IGateDetector
+    {
+        private readonly DetectedGate[] _gates;
+        public GateType GateType => GateType.NonDefaultConfig;
+
+        public MockConfigDetector(params DetectedGate[] gates) => _gates = gates;
+
+        public Task<IReadOnlyList<DetectedGate>> DetectAsync(CallPathContext context, CancellationToken ct)
+            => Task.FromResult<IReadOnlyList<DetectedGate>>(_gates);
+    }
+
+    private sealed class FailingGateDetector : IGateDetector
+    {
+        public GateType GateType => GateType.AuthRequired;
+
+        public Task<IReadOnlyList<DetectedGate>> DetectAsync(CallPathContext context, CancellationToken ct)
+            => throw new InvalidOperationException("Simulated detector failure");
+    }
+}
+