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.
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;
}
}
}