up

tests/reachability/StellaOps.Signals.Reachability.Tests/RuntimeFactsIngestionServiceTests.cs

@@ -15,12 +15,23 @@ namespace StellaOps.Signals.Reachability.Tests;
 public sealed class RuntimeFactsIngestionServiceTests
 {
     private readonly FakeReachabilityFactRepository repository = new();
+    private readonly FakeReachabilityCache cache = new();
+    private readonly FakeEventsPublisher eventsPublisher = new();
+    private readonly FakeScoringService scoringService = new();
+    private readonly FakeProvenanceNormalizer provenanceNormalizer = new();
     private readonly FakeTimeProvider timeProvider = new(DateTimeOffset.Parse("2025-11-09T10:15:00Z", null, System.Globalization.DateTimeStyles.AssumeUniversal));
     private readonly RuntimeFactsIngestionService sut;
 
     public RuntimeFactsIngestionServiceTests()
     {
-        sut = new RuntimeFactsIngestionService(repository, timeProvider, NullLogger<RuntimeFactsIngestionService>.Instance);
+        sut = new RuntimeFactsIngestionService(
+            repository,
+            timeProvider,
+            cache,
+            eventsPublisher,
+            scoringService,
+            provenanceNormalizer,
+            NullLogger<RuntimeFactsIngestionService>.Instance);
     }
 
     [Fact]
@@ -145,4 +156,83 @@ public sealed class RuntimeFactsIngestionServiceTests
         public Task<ReachabilityFactDocument?> GetBySubjectAsync(string subjectKey, CancellationToken cancellationToken) =>
             Task.FromResult(LastUpsert is { SubjectKey: not null } doc && doc.SubjectKey == subjectKey ? doc : null);
     }
+
+    private sealed class FakeReachabilityCache : IReachabilityCache
+    {
+        private readonly Dictionary<string, ReachabilityFactDocument> storage = new(StringComparer.Ordinal);
+
+        public Task<ReachabilityFactDocument?> GetAsync(string subjectKey, CancellationToken cancellationToken)
+        {
+            storage.TryGetValue(subjectKey, out var document);
+            return Task.FromResult(document);
+        }
+
+        public Task SetAsync(ReachabilityFactDocument document, CancellationToken cancellationToken)
+        {
+            storage[document.SubjectKey] = document;
+            return Task.CompletedTask;
+        }
+
+        public Task InvalidateAsync(string subjectKey, CancellationToken cancellationToken)
+        {
+            storage.Remove(subjectKey);
+            return Task.CompletedTask;
+        }
+    }
+
+    private sealed class FakeEventsPublisher : IEventsPublisher
+    {
+        public List<ReachabilityFactDocument> Published { get; } = new();
+
+        public Task PublishFactUpdatedAsync(ReachabilityFactDocument fact, CancellationToken cancellationToken)
+        {
+            Published.Add(fact);
+            return Task.CompletedTask;
+        }
+    }
+
+    private sealed class FakeScoringService : IReachabilityScoringService
+    {
+        public List<ReachabilityRecomputeRequest> Requests { get; } = new();
+
+        public Task<ReachabilityFactDocument> RecomputeAsync(ReachabilityRecomputeRequest request, CancellationToken cancellationToken)
+        {
+            Requests.Add(request);
+            return Task.FromResult(new ReachabilityFactDocument
+            {
+                Subject = request.Subject,
+                SubjectKey = request.Subject.ToSubjectKey(),
+                CallgraphId = request.CallgraphId,
+                ComputedAt = TimeProvider.System.GetUtcNow()
+            });
+        }
+    }
+
+    private sealed class FakeProvenanceNormalizer : IRuntimeFactsProvenanceNormalizer
+    {
+        public ProvenanceFeed NormalizeToFeed(
+            IEnumerable<RuntimeFactEvent> events,
+            ReachabilitySubject subject,
+            string callgraphId,
+            Dictionary<string, string?>? metadata,
+            DateTimeOffset generatedAt) => new()
+        {
+            FeedId = "fixture",
+            GeneratedAt = generatedAt,
+            CorrelationId = callgraphId,
+            Records = new List<ProvenanceRecord>()
+        };
+
+        public ContextFacts CreateContextFacts(
+            IEnumerable<RuntimeFactEvent> events,
+            ReachabilitySubject subject,
+            string callgraphId,
+            Dictionary<string, string?>? metadata,
+            DateTimeOffset timestamp) => new()
+        {
+            Provenance = NormalizeToFeed(events, subject, callgraphId, metadata, timestamp),
+            LastUpdatedAt = timestamp,
+            RecordCount = events is ICollection<RuntimeFactEvent> collection ? collection.Count : 0
+        };
+    }
 }