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 AqRecovery;

namespace AqRecovery.Tests;

/// <summary>
/// Gateway en memoria con semántica transaccional real: los cambios solo se aplican en commit.
/// Permite probar el worker sin Oracle, incluyendo fallas a mitad de la transacción.
/// </summary>
public sealed class FakeGateway : IRecoveryGateway
{
    public Queue<QueueMessage> ExceptionQueue { get; } = new();
    public List<(QueueMessage Message, TimeSpan Delay)> TargetQueue { get; } = new();
    public List<(QueueMessage Message, string Reason)> ManualReview { get; } = new();
    public List<AuditEntry> Audit { get; } = new();

    /// <summary>Si se define, el reencolado falla para ese MessageId.</summary>
    public string? FailRequeueFor { get; set; }

    public Task<IRecoveryUnitOfWork> BeginAsync(CancellationToken cancellationToken) =>
        Task.FromResult<IRecoveryUnitOfWork>(new UnitOfWork(this));

    public Task<int> GetRecoveryAttemptsAsync(string correlationKey, CancellationToken cancellationToken) =>
        Task.FromResult(Audit.Count(a => (a.CorrelationId ?? a.MessageId) == correlationKey));

    private sealed class UnitOfWork : IRecoveryUnitOfWork
    {
        private readonly FakeGateway _g;
        private readonly List<Action> _pending = new();
        private QueueMessage? _dequeued;
        private bool _committed;

        public UnitOfWork(FakeGateway g) => _g = g;

        public Task<QueueMessage?> DequeueAsync(CancellationToken ct)
        {
            _dequeued = _g.ExceptionQueue.Count > 0 ? _g.ExceptionQueue.Dequeue() : null;
            return Task.FromResult(_dequeued);
        }

        public Task RequeueAsync(QueueMessage m, TimeSpan delay, CancellationToken ct)
        {
            if (_g.FailRequeueFor == m.MessageId) throw new TimeoutException("Simulación de falla en Oracle");
            _pending.Add(() => _g.TargetQueue.Add((m, delay)));
            return Task.CompletedTask;
        }

        public Task MoveToManualReviewAsync(QueueMessage m, string reason, CancellationToken ct)
        {
            _pending.Add(() => _g.ManualReview.Add((m, reason)));
            return Task.CompletedTask;
        }

        public Task RecordAuditAsync(AuditEntry entry, CancellationToken ct)
        {
            _pending.Add(() => _g.Audit.Add(entry));
            return Task.CompletedTask;
        }

        public Task CommitAsync(CancellationToken ct)
        {
            _pending.ForEach(a => a());
            _committed = true;
            return Task.CompletedTask;
        }

        public ValueTask DisposeAsync()
        {
            // Rollback: el mensaje desencolado regresa a la exception queue.
            if (!_committed && _dequeued is not null)
            {
                var rest = _g.ExceptionQueue.ToArray();
                _g.ExceptionQueue.Clear();
                _g.ExceptionQueue.Enqueue(_dequeued);
                foreach (var m in rest) _g.ExceptionQueue.Enqueue(m);
            }
            return ValueTask.CompletedTask;
        }
    }
}