Premiere commit - Omika

tests/Omika.Tests/Observability/External/ExternalObservabilityCountersTests.cs

@@ -0,0 +1,88 @@
+using Omika.Core.Observability.External;
+
+namespace Omika.Tests.Observability.External;
+
+/// <summary>
+/// Compteurs du pont externe (Phase 5) : valeurs initiales à 0, incréments exacts,
+/// thread-safe (Interlocked), jamais-throw. Compteurs purement mémoire — jamais
+/// réinjectés dans IOmikaTelemetry (anti-boucle).
+/// </summary>
+public class ExternalObservabilityCountersTests
+{
+    [Fact]
+    public void AllCounters_StartAtZero()
+    {
+        var counters = new ExternalObservabilityCounters();
+
+        Assert.Equal(0, counters.Accepted);
+        Assert.Equal(0, counters.Exported);
+        Assert.Equal(0, counters.DroppedDisabled);
+        Assert.Equal(0, counters.DroppedCircuitOpen);
+        Assert.Equal(0, counters.DroppedSecurity);
+        Assert.Equal(0, counters.DroppedInvalid);
+        Assert.Equal(0, counters.DroppedInternal);
+        Assert.Equal(0, counters.Failure);
+        Assert.Equal(0, counters.CircuitOpened);
+        Assert.Equal(0, counters.Forwarded);
+        Assert.Equal(0, counters.ForwardFailure);
+    }
+
+    [Fact]
+    public void Increments_AreExact()
+    {
+        var counters = new ExternalObservabilityCounters();
+
+        counters.IncrementAccepted();
+        counters.IncrementExported(7);
+        counters.IncrementDroppedDisabled();
+        counters.IncrementDroppedCircuitOpen();
+        counters.IncrementDroppedSecurity();
+        counters.IncrementDroppedInvalid();
+        counters.IncrementDroppedInternal();
+        counters.IncrementFailure();
+        counters.IncrementCircuitOpened();
+        counters.IncrementForwarded(3);
+        counters.IncrementForwardFailure();
+
+        Assert.Equal(1, counters.Accepted);
+        Assert.Equal(7, counters.Exported);
+        Assert.Equal(1, counters.DroppedDisabled);
+        Assert.Equal(1, counters.DroppedCircuitOpen);
+        Assert.Equal(1, counters.DroppedSecurity);
+        Assert.Equal(1, counters.DroppedInvalid);
+        Assert.Equal(1, counters.DroppedInternal);
+        Assert.Equal(1, counters.Failure);
+        Assert.Equal(1, counters.CircuitOpened);
+        Assert.Equal(3, counters.Forwarded);
+        Assert.Equal(1, counters.ForwardFailure);
+    }
+
+    [Fact]
+    public void IncrementExported_AccumulatesByCount()
+    {
+        var counters = new ExternalObservabilityCounters();
+
+        counters.IncrementExported(5);
+        counters.IncrementExported(11);
+
+        Assert.Equal(16, counters.Exported);
+    }
+
+    [Fact]
+    public void ConcurrentIncrements_ProduceExactTotal()
+    {
+        const int threads = 8;
+        const int perThread = 1000;
+        var counters = new ExternalObservabilityCounters();
+
+        Parallel.For(0, threads, _ =>
+        {
+            for (int i = 0; i < perThread; i++)
+            {
+                counters.IncrementAccepted();
+            }
+        });
+
+        Assert.Equal(threads * perThread, counters.Accepted);
+    }
+}