Código

Basado en el problema que fui el primero en resolver en Totalplay

Recuperación de la Exception Queue de Oracle AQ

Miles de clientes atorados, sin que nadie lo supiera.

C# 81%SQL 13%MSBuild 6%15 archivos729 líneas de código 9/9 pruebas
using System.Text;
using AqRecovery;
using AqRecovery.Tests;

var now = new DateTimeOffset(2026, 11, 18, 12, 0, 0, TimeSpan.Zero);
var clock = new FixedClock(now);
var policy = new RecoveryPolicy(new RecoveryPolicyOptions(MaxRecoveryAttempts: 3), clock);

QueueMessage Msg(string id, string json = """{"cuenta":123,"promocion":"P-9"}""", int ageDays = 0, string? corr = null) =>
    new(id, corr ?? $"CORR-{id}", Encoding.UTF8.GetBytes(json), now.AddDays(-ageDays));

var tests = new (string Name, Func<Task> Run)[]
{
    ("Mensaje vacío va a revisión manual", () =>
    {
        var a = policy.Decide(new QueueMessage("1", null, Array.Empty<byte>(), now), 0);
        Assert.Equal(RecoveryActionKind.ManualReview, a.Kind);
        return Task.CompletedTask;
    }),
    ("JSON inválido va a revisión manual", () =>
    {
        Assert.Equal(RecoveryActionKind.ManualReview, policy.Decide(Msg("1", "{no es json"), 0).Kind);
        return Task.CompletedTask;
    }),
    ("Mensaje con más de 7 días va a revisión manual", () =>
    {
        Assert.Equal(RecoveryActionKind.ManualReview, policy.Decide(Msg("1", ageDays: 8), 0).Kind);
        return Task.CompletedTask;
    }),
    ("Al agotar los intentos va a revisión manual", () =>
    {
        Assert.Equal(RecoveryActionKind.Requeue, policy.Decide(Msg("1"), 2).Kind);
        Assert.Equal(RecoveryActionKind.ManualReview, policy.Decide(Msg("1"), 3).Kind);
        return Task.CompletedTask;
    }),
    ("Backoff exponencial con tope", () =>
    {
        Assert.Equal(TimeSpan.FromMinutes(5), policy.BackoffFor(0));
        Assert.Equal(TimeSpan.FromMinutes(10), policy.BackoffFor(1));
        Assert.Equal(TimeSpan.FromMinutes(20), policy.BackoffFor(2));
        Assert.Equal(TimeSpan.FromHours(2), policy.BackoffFor(30));
        return Task.CompletedTask;
    }),
    ("El worker reencola los válidos y aparta los ilegibles", async () =>
    {
        var g = new FakeGateway();
        g.ExceptionQueue.Enqueue(Msg("A"));
        g.ExceptionQueue.Enqueue(Msg("B", "basura"));
        g.ExceptionQueue.Enqueue(Msg("C"));
        var r = await new RecoveryWorker(g, policy, "EXQ").RunOnceAsync(100);
        Assert.Equal(2, r.Requeued);
        Assert.Equal(1, r.SentToReview);
        Assert.Equal(0, g.ExceptionQueue.Count);
        Assert.Equal(3, g.Audit.Count);
    }),
    ("Una falla revierte ese mensaje sin perderlo ni girar en falso", async () =>
    {
        var g = new FakeGateway { FailRequeueFor = "B" };
        g.ExceptionQueue.Enqueue(Msg("A"));
        g.ExceptionQueue.Enqueue(Msg("B"));
        g.ExceptionQueue.Enqueue(Msg("C"));
        var r = await new RecoveryWorker(g, policy, "EXQ").RunOnceAsync(100);
        Assert.Equal(1, r.Failed);                          // B falló una sola vez, no 98
        Assert.Equal(1, r.Requeued);                        // A se recuperó
        Assert.Equal("B", g.ExceptionQueue.Peek().MessageId); // B sigue en la exception queue, intacto
        Assert.True(g.Audit.All(a => a.MessageId != "B"), "No debe auditarse un mensaje revertido");

        g.FailRequeueFor = null;                            // la siguiente corrida, ya sin falla
        var r2 = await new RecoveryWorker(g, policy, "EXQ").RunOnceAsync(100);
        Assert.Equal(2, r2.Requeued);
        Assert.Equal(0, g.ExceptionQueue.Count);
    }),
    ("Se detiene cuando la exception queue está vacía", async () =>
    {
        var r = await new RecoveryWorker(new FakeGateway(), policy, "EXQ").RunOnceAsync(1_000);
        Assert.Equal(0, r.Total);
    }),
    ("Un mensaje veneno termina en revisión tras 3 recuperaciones", async () =>
    {
        var g = new FakeGateway();
        var worker = new RecoveryWorker(g, policy, "EXQ");
        g.ExceptionQueue.Enqueue(Msg("X", corr: "PEDIDO-77"));
        for (var run = 0; run < 3; run++)
        {
            await worker.RunOnceAsync(10);
            // El consumidor vuelve a fallar: Oracle lo regresa a la exception queue con otro MessageId.
            var (m, _) = g.TargetQueue[^1];
            g.ExceptionQueue.Enqueue(m with { MessageId = $"X{run}" });
        }
        var final = await worker.RunOnceAsync(10);
        Assert.Equal(1, final.SentToReview);
        Assert.Equal(1, g.ManualReview.Count);
        Assert.Equal(new[] { 5.0, 10.0, 20.0 }, g.TargetQueue.Select(t => t.Delay.TotalMinutes).ToArray());
    }),
};

var failed = 0;
foreach (var (name, run) in tests)
{
    try { await run(); Console.WriteLine($"  ✓ {name}"); }
    catch (Exception ex) { failed++; Console.WriteLine($"  ✗ {name}\n      {ex.Message}"); }
}
Console.WriteLine($"\n{tests.Length - failed}/{tests.Length} pruebas pasaron.");
return failed == 0 ? 0 : 1;

sealed class FixedClock(DateTimeOffset now) : TimeProvider
{
    public override DateTimeOffset GetUtcNow() => now;
}

static class Assert
{
    public static void Equal<T>(T expected, T actual)
    {
        var equal = expected is System.Collections.IEnumerable e && actual is System.Collections.IEnumerable a && expected is not string
            ? e.Cast<object>().SequenceEqual(a.Cast<object>())
            : EqualityComparer<T>.Default.Equals(expected, actual);
        if (!equal) throw new Exception($"Se esperaba «{Fmt(expected)}» y se obtuvo «{Fmt(actual)}».");
    }

    public static void True(bool condition, string message)
    {
        if (!condition) throw new Exception(message);
    }

    private static string Fmt<T>(T v) => v is System.Collections.IEnumerable e && v is not string
        ? "[" + string.Join(", ", e.Cast<object>()) + "]"
        : v?.ToString() ?? "null";
}