Omika/tests/Omika.Tests/Observability/PriorityTelemetryQueueTests.cs

using Omika.Core.Configuration;
using Omika.Core.Observability;

namespace Omika.Tests.Observability;

public class PriorityTelemetryQueueTests
{
    private static (PriorityTelemetryQueue Queue, TelemetryCounters Counters) CreateQueue(
        int p0 = 2, int p1 = 2, int p2 = 2, int p3 = 2, int p4 = 2)
    {
        var options = new ObservabilityOptions
        {
            P0QueueCapacity = p0,
            P1QueueCapacity = p1,
            P2QueueCapacity = p2,
            P3QueueCapacity = p3,
            P4QueueCapacity = p4
        };
        var counters = new TelemetryCounters();
        return (new PriorityTelemetryQueue(options, counters), counters);
    }

    private static TelemetryEvent Event(TelemetryPriority priority) =>
        new() { EventCode = TelemetryEventCodes.MobileAppStarted, Priority = priority };

    [Fact]
    public void Enqueue_ThenCount_Increments()
    {
        var (queue, _) = CreateQueue();

        queue.TryEnqueue(Event(TelemetryPriority.P3));

        Assert.Equal(1, queue.Count);
    }

    [Fact]
    public void EachPriority_UsesItsOwnQueue()
    {
        var (queue, _) = CreateQueue();

        queue.TryEnqueue(Event(TelemetryPriority.P0));
        queue.TryEnqueue(Event(TelemetryPriority.P1));
        queue.TryEnqueue(Event(TelemetryPriority.P2));
        queue.TryEnqueue(Event(TelemetryPriority.P3));
        queue.TryEnqueue(Event(TelemetryPriority.P4));

        Assert.Equal(1, queue.GetQueueCount(TelemetryPriorityQueues.P0));
        Assert.Equal(1, queue.GetQueueCount(TelemetryPriorityQueues.P1));
        Assert.Equal(1, queue.GetQueueCount(TelemetryPriorityQueues.P2));
        Assert.Equal(1, queue.GetQueueCount(TelemetryPriorityQueues.P3));
        Assert.Equal(1, queue.GetQueueCount(TelemetryPriorityQueues.P4));
    }

    [Fact]
    public void P4Full_NewP3_IsAccepted()
    {
        var (queue, counters) = CreateQueue(p4: 1);

        Assert.True(queue.TryEnqueue(Event(TelemetryPriority.P4)));
        // File P4 pleine : le P3 part dans sa propre file, indépendante.
        Assert.True(queue.TryEnqueue(Event(TelemetryPriority.P3)));

        Assert.Equal(1, queue.GetQueueCount(TelemetryPriorityQueues.P4));
        Assert.Equal(1, queue.GetQueueCount(TelemetryPriorityQueues.P3));
        Assert.Equal(0L, counters.DroppedQueueFull);
    }

    [Fact]
    public void P1Full_NewP0_IsAccepted_P1Unchanged()
    {
        var (queue, counters) = CreateQueue(p1: 2, p0: 2);

        Assert.True(queue.TryEnqueue(Event(TelemetryPriority.P1)));
        Assert.True(queue.TryEnqueue(Event(TelemetryPriority.P1)));
        // File P1 saturée : le P0 est accepté dans sa propre file, P1 inchangé.
        Assert.True(queue.TryEnqueue(Event(TelemetryPriority.P0)));

        Assert.Equal(2, queue.GetQueueCount(TelemetryPriorityQueues.P1));
        Assert.Equal(1, queue.GetQueueCount(TelemetryPriorityQueues.P0));
        Assert.Equal(0L, counters.DroppedQueueFull);
    }

    [Fact]
    public void P0Full_NewP0_IsDropped_Immediately_WithCounter()
    {
        var (queue, counters) = CreateQueue(p0: 1);

        Assert.True(queue.TryEnqueue(Event(TelemetryPriority.P0)));
        // Retourne immédiatement (aucun blocage), événement abandonné, compteur P0 incrémenté.
        Assert.False(queue.TryEnqueue(Event(TelemetryPriority.P0)));

        Assert.Equal(1L, counters.DroppedQueueFull);
        Assert.Equal(1L, counters.DroppedP0);
        Assert.Equal(1L, counters.GetPriorityDropCount(TelemetryPriorityQueues.P0));
        Assert.Equal(0L, counters.DroppedP1);
        Assert.Equal(1, queue.Count);
    }

    [Fact]
    public void TryRead_DrainsInPriorityOrder()
    {
        var (queue, _) = CreateQueue();

        queue.TryEnqueue(Event(TelemetryPriority.P0));
        queue.TryEnqueue(Event(TelemetryPriority.P4));

        Assert.True(queue.TryRead(TelemetryPriorityQueues.P0, out OmikaEvent critical));
        Assert.True(queue.TryRead(TelemetryPriorityQueues.P4, out OmikaEvent analytics));

        Assert.Equal(TelemetryPriority.P0, critical.EffectivePriority);
        Assert.Equal(TelemetryPriority.P4, analytics.EffectivePriority);
        Assert.Equal(0, queue.Count);
    }

    [Fact]
    public void InvalidCapacity_DoesNotThrow_AndIsClamped()
    {
        var (queue, _) = CreateQueue(p0: -5, p1: 0);

        Assert.Equal(1, queue.CapacityP0);
        Assert.Equal(1, queue.CapacityP1);
        Assert.Equal(1 + 1 + 2 + 2 + 2, queue.TotalCapacity);
    }

    [Fact]
    public void TotalCapacity_IsSumOfFiveQueues()
    {
        var (queue, _) = CreateQueue(p0: 1, p1: 2, p2: 3, p3: 4, p4: 5);

        Assert.Equal(15, queue.TotalCapacity);
        Assert.Equal(1, queue.CapacityP0);
        Assert.Equal(2, queue.CapacityP1);
        Assert.Equal(3, queue.CapacityP2);
        Assert.Equal(4, queue.CapacityP3);
        Assert.Equal(5, queue.CapacityP4);
    }
}